fix(ui): inboxWindow 기본 크기 1200×800 → 1440×900 (헤더 버튼 뭉개짐 해소)

tag(키워드) vs notebook(컨텍스트) 의미 분리 — chip 을 이동 버튼 왼쪽에 배치.
dropdown 방향을 top→bottom(아래로) 에서 bottom→top(위로) 으로 변경 (footer 위치 대응).

.gitignore

@@ -11,3 +11,7 @@ test-results/
 # build/ 산출물 — icon.{ico,icns,png} 만 커밋, 중간 산출물은 무시
 build/icons/
 build/icon-source.png
+
+# Claude Code 로컬 worktree + 사용자별 settings
+.claude/worktrees/
+.claude/settings.local.json

CHANGELOG.md

@@ -3,6 +3,373 @@
 본 파일은 Inkling 의 버전별 사용자 영향 변경 사항을 기록한다.
 형식은 [Keep a Changelog](https://keepachangelog.com/) 를 느슨하게 따른다.
 
+## [0.4.0] — 2026-05-15 (force re-tag, dogfood UX 2회 보완)
+
+### 추가 dogfood UX 2회차 (2026-05-15 force re-tag)
+
+dogfood 2일차 피드백 묶음. force re-tag 로 같은 v0.4.0 에 추가.
+
+- **AI 정리하기 (default notebook batch 분류)** — 사이드바 default notebook 선택 시 main 영역 상단에 "🪄 AI 정리하기" 버튼. 클릭 → AI 가 default 의 active 노트들을 한 prompt 에 묶어 분석 → BatchMoveModal 에 noteId 별 추천 notebook + checkbox → 사용자 confirm 후 일괄 moveNote. top N=50 cap, 한국어 prompt, hallucinated notebook 이름은 null 로 coerce.
+- **노트북 순서 변경** — `notebooks.sort_order` 컬럼 (m009 마이그레이션) + NotebookList row hover 시 ↑↓ 버튼. 인접 sort_order swap. drag-drop 은 v0.5+ 후보.
+- **이동 UX 정리** — NoteCard 의 notebook chip 을 tag 영역 → footer 의 "이동" 버튼 옆으로 이동. tag(키워드) / notebook(컨텍스트) 의미 분리. dropdown 도 위쪽으로 펼침.
+
+### 추가 dogfood UX 1회차 (2026-05-15)
+
+- **NotebookChip 시각 강화** — 청색 배경 + 📓 아이콘 + ▾ caret + dropdown 헤더 "이동할 노트북". chip 클릭 시 다른 notebook 선택 dropdown 이 보이는 affordance 명확화. 다른 notebook 없으면 disabled.
+- **헤더 좌측 ☰ 햄버거 버튼** — 마우스 클릭으로 사이드바 토글 (Cmd/Ctrl+B 단축키와 동일).
+- **사이드바 default visible** — 새 사용자가 처음부터 사이드바 보이게 (`settings.getSidebarVisible` default false → true). 기존 사용자가 명시적으로 false 저장했다면 그 값 그대로.
+- **inboxWindow 기본 크기 확장** — 900×720 → 1200×800. 사이드바 240px 가 default 가시화되므로 main 영역 확보.
+
+### 게이트 (2회차 후)
+
+- 단위 877 PASS
+- typecheck 0 errors
+
+---
+
+### 원본 release (2026-05-15)
+
+Notebooks + Lifecycle Simplification. 19일 dogfood 데이터 (archived 0건 / mlx-ops tag 가 사실상 컨텍스트 그룹 역할) 가 묶음 변경의 근거.
+
+### 추가
+
+- **Notebook 카테고리** — 좌측 사이드바 (Cmd+B / Ctrl+B 토글), 색 + count badge. notebooks 테이블 + notes.notebook_id FK RESTRICT. m008 마이그레이션이 default "기본" notebook 자동 생성 후 모든 기존 노트 배치.
+- **AI 자동 fit 매칭** — 매 capture 시 AI 가 prompt 의 notebooks 목록을 보고 best-fit 자동 배치 (응답의 notebook_match 필드). NoteCard 의 chip 으로 1-click 변경 가능.
+- **Promotion 제안** — 같은 tag 가 3건 이상 default notebook 에 누적되면 "새 notebook 으로 분리?" banner 표시. 24h snooze + 영구 dismiss 지원 (settings 의 promotion_snoozed_until_ms / promotion_dismissed_tags 영속화).
+- **사이드바 UX** — NotebookCreateModal (이름 + 6색 palette + 중복 검증), NotebookList (선택 highlight + count), 모달/사이드바 toggle 단축키.
+- **검색 scope 토글** — "이 노트북" / "모든 노트북" dropdown.
+
+### 변경
+
+- **lifecycle 3분기** — `archived` status 제거. 헤더 탭이 Inbox / 완료 / 휴지통 (3탭). MoveStatusModal 의 "보관" 옵션도 제거. classifyStatus 의 AI 응답이 archived 면 completed 로 coerce. ImportService 가 backward compat 위해 archived 노트 import 시 completed 로 변환.
+- **NoteRepository.findExpiredCandidates** 의 scope 가 inbox 만 → notebook 별 scope (Task 4 의 countByStatus 옵션 등 통합 효과).
+- selectedNotebookId 변경 시 list / counts 자동 refresh.
+
+### 게이트
+
+- 단위 테스트 851 PASS (m008 마이그레이션 / NotebookRepository / AI prompt + schema / AiWorker matching / store + settings 영속화 / Sidebar / NotebookCreateModal / PromotionBanner / NoteCard chip / SearchBox scope / archived 제거 회귀 가드).
+- typecheck 0 errors.
+- 신규 npm dependency 0.
+
+### 업그레이드
+
+v0.3.14 인스톨러 위에 v0.4.0 인스톨러를 같은 위치에 실행하면 in-place 업그레이드. m008 마이그레이션이 첫 launch 시 자동 실행되어 default notebook "기본" 생성 + 모든 기존 노트 배치.
+
+## [0.3.14] — 2026-05-12 (force re-tag: 2026-05-14, 추가 dogfood fixes 7건)
+
+### 추가 dogfood fixes (2026-05-14 force re-tag)
+
+force re-tag 로 같은 v0.3.14 안에 묶인 후속 변경. 새 minor 안 늘리고 동일 release notes 확장.
+
+- **fix(capture): QuickCapture blur-on-hide 제거.** 다른 창 클릭해도 ESC / Cmd+Enter 까지 창 유지. alwaysOnTop + screen-saver level 로 다른 앱 위에 떠 있음.
+- **chore(ux): macOS 사용자 위해 Cmd 키 hint 안내.** Inbox empty state 와 QuickCapture 하단 hint 가 platform-aware 로 분기 — Mac 에선 `Cmd+Shift+J` / `Cmd+Enter`.
+- **fix(macos): hidden autostart dock indicator + autostart mismatch false positive.** ① LoginItems `--hidden` spawn 시 NSPanel 만 떠 있어 dock 점 안 보이던 문제 — inboxWindow 를 hidden 으로 미리 create + `showInactive → hide` trick 으로 NSApp register. ② SettingsPage 의 자동실행 mismatch 경고가 macOS 13+ SMAppService 한계로 false positive 떠 있던 문제 — willLaunch 신호는 win32 에서만 mismatch 판정에 사용.
+- **feat(notes): 원문 편집/이력 복원 시 AI 재처리.** `NoteRepository.markAiPendingForReprocess` 신설 — done/failed/pending 노트를 pending reset + pending_jobs 재투입. disabled 는 사용자 의도 존중 no-op. NoteCard.saveRaw 가 optimistic 으로 `aiStatus='pending'` 표시. updateAiResult 의 user-edit 가드로 사용자가 직접 편집한 필드는 보존.
+- **feat(expiry): 마감 알림 inbox 제한 + 오늘 당일 포함 + 헤딩/라벨/메모 바로가기.** ① `findExpiredCandidates` 가 `due_date <= today` + `status='active'` 로 변경, 완료/보관 노트는 제외. 정렬도 `due_date DESC` 로 오늘 → 어제 순. ② ExpiryBanner 헤딩 분리 카운트 "오늘 마감 X · 지난 Y", 노트 라벨 [오늘] / [N일 지남]. ③ 노트 제목 클릭 → `note-{id}` smooth scroll.
+- **fix(sync): manifest.exported_at 제거 — no-op push 회피.** 노트 변경 0건이어도 매 sync 마다 timestamp 1줄 commit + push 가 쌓이던 문제. `composeManifest` 에서 cosmetic 필드 제거. 이제 진짜 변경 있을 때만 commit.
+- **feat(settings): SectionIntro + SyncHelpModal 풀어쓰기.** 설정 페이지 6 section 상단에 1-2 문장 안내. SyncHelpModal 의 기술 용어 (rebase, fast-forward, NTP) 를 사용자 언어로 풀어쓰기.
+
+### 게이트 (추가 fix 후)
+
+- 단위 763 PASS
+- typecheck 0 errors
+
+---
+
+### 원본 release (2026-05-12)
+
+AI 처리 fail 원인 가시화. 이전엔 ai_error 가 NoteCard tooltip (title attribute) 에만 있어 사용자가 마우스 오버해야 보이는 데다 raw 메시지만 노출 → 무엇이 fail 했는지 불명.
+
+### 수정
+
+- **NoteCard failed 노트에 "원인 보기" 접힘 섹션 (P1).** `<details>` summary 클릭하면 `<pre>` 로 `ai_error` 전체 노출. wrap + word-break 적용. 사용자가 직접 메시지를 보고 모델/네트워크/JSON 등 fail 카테고리 진단 가능.
+- **`ai_error` 에 reason + provider name prefix 추가.** AiWorker 의 markAiFailed 시 `[schema|other] local-ollama/gemma4:26b\n<원본 message>` 형식. 사용자가 어느 카테고리에서, 어느 모델로 실패했는지 즉시 식별. log 의 ai.failed 에도 reason/provider 필드 함께 출력.
+
+### 게이트
+
+- 단위 752 PASS (ai_error 포맷 변경은 test 영향 없음 — 기존 test 가 정확한 prefix 매칭 안 함)
+- typecheck 0 errors
+- 신규 npm dependency 0
+
+### 사용자 안내
+
+이미지 AI 처리가 fail 한다면 NoteCard 의 "정리 보류" 옆 "원인 보기" 클릭 → 표시되는 메시지로:
+- `[timeout] ...` → vision 모델 cold-start 가 5분 초과. `ollama run gemma4:26b` 으로 한번 warm-up 후 재시도
+- `[schema] title must contain Korean characters` → vision 모델이 영어 title 반환. prompt 가 한국어 강조했지만 일부 모델은 여전히 영어. `gemma3:27b` 등 다른 vision 모델로 대체 고려
+- `[schema] unparseable response: ...` → vision 모델 JSON 출력 안 따름. v0.3.12 의 loose parse 가 실패한 경우
+- `[other] missing response field` → Ollama 가 빈 응답 반환. 모델 자체 문제
+
+### 업그레이드
+
+v0.3.13 인스톨러 위에 v0.3.14 인스톨러를 같은 위치에 실행하면 in-place 업그레이드.
+
+## [0.3.13] — 2026-05-12
+
+대형 vision 모델 (gemma4:26b 등) 의 cold-start timeout 으로 인한 AI 처리 실패 fix.
+
+### 수정
+
+- **Vision generate 의 timeout 확장 120s → 300s (P1).** `gemma4:26b` (25B MoE 가중치 + vision encoder 550M) 같은 대형 vision 모델은 첫 generate 시 모델 load + 이미지 encoding 으로 60-180s 소요. 기본 120s timeout 으로 첫 호출 시 abort → fail 빈번. vision path 에 한해 `Math.max(timeoutMs, 300_000)` 적용 (text-only path 영향 없음).
+
+확인: gemma4 family 는 [공식 release](https://blog.google/innovation-and-ai/technology/developers-tools/gemma-4/) — 26B variant 가 Text+Image 양 modality 지원 ([ollama library](https://ollama.com/library/gemma4:26b)). 본 코드의 `VisionDetect` 가 'gemma4' family 인식하므로 사용자가 settings → Vision 섹션에서 선택 가능.
+
+### 사용자 안내
+
+이미지 AI 처리가 여전히 실패한다면:
+1. 설정 → AI 제공자 → Vision 섹션에서 `gemma4:26b` (또는 vision-capable 모델) 가 선택돼있는지 확인
+2. `ollama list` 로 모델 실제 설치 여부 확인 (`ollama pull gemma4:26b` 필요)
+3. NoteCard 의 failed 노트 텍스트 위에 마우스 오버 → tooltip 의 `ai_error` 확인 (구체 fail mode 진단)
+
+### 게이트
+
+- 단위 752 PASS (timeout 상수만 변경 — 회귀 없음)
+- typecheck 0 errors
+- 신규 npm dependency 0
+
+### 업그레이드
+
+v0.3.12 인스톨러 위에 v0.3.13 인스톨러를 같은 위치에 실행하면 in-place 업그레이드.
+
+## [0.3.12] — 2026-05-12
+
+이미지 AI 처리 실패 fix. vision model 의 응답이 strict JSON 이 아닌 경우 (markdown fence / prose 섞임) 가 흔해 schema parse 단계에서 throw → `ai_status='failed'` 도달.
+
+### 수정
+
+- **Vision model 응답 JSON loose parse (P1).** `LocalOllamaProvider.generate` 의 `JSON.parse` 가 strict 라 vision-tuned 모델의 markdown 코드 펜스 / 앞뒤 prose 응답에서 throw. `parseJsonLoose` 헬퍼 추가 — 첫 `{` ~ 마지막 `}` substring 추출 fallback. 실패 시 raw response 200자 snippet 포함한 에러 throw (디버깅 가시화).
+- **Vision prompt 강화 (P1).** `buildVisionPrompt` 가 "title 한국어로 요약" 만 명시 → schema 의 KOREAN_REGEX/KEBAB_REGEX 강제와 불일치. 규칙 4건 명시: title 한국어 60자, summary 3줄, tags 영문 kebab-case 3개, due_date ISO 또는 null. "markdown 코드 펜스 금지" 명시로 JSON-only 출력 강제.
+
+알려진 한계:
+- `gemma4:26b` 같이 Ollama 에 실제로 release 안 된 모델명 사용 시 healthCheck 통과해도 generate 가 unknown model 로 throw. 모델 설치 여부는 사용자가 `ollama list` 확인 필요.
+
+### 게이트
+
+- 단위 750 → **752 PASS** (+2: markdown fence 추출 + prose 추출)
+- typecheck 0 errors
+- 신규 npm dependency 0
+
+### 업그레이드
+
+v0.3.11 인스톨러 위에 v0.3.12 인스톨러를 같은 위치에 실행하면 in-place 업그레이드. 데이터/마이그레이션 변경 없음.
+
+## [0.3.11] — 2026-05-12
+
+붙여넣은 이미지 / 저장된 이미지가 양쪽 창에서 표시 안 되던 CSP 누락 hotfix.
+
+### 수정
+
+- **QuickCapture: paste 이미지 thumbnail 렌더 실패.** `quickcapture/index.html` 의 CSP 가 `img-src` 미지정 → `default-src 'self'` fallback → `URL.createObjectURL` 의 `blob:` URL 차단. `img-src 'self' data: blob:` 추가.
+- **Inbox: 저장된 노트 이미지 렌더 실패.** `inbox/index.html` 의 CSP `img-src 'self' data: blob: file:` 가 `inkling-media:` 미허용 → `NoteCard` 의 `<img src="inkling-media://media/..." />` 차단 (custom protocol 자체는 main 에서 등록됐지만 renderer CSP 별도). `inkling-media:` 추가.
+
+v0.3.0 (Cut A 이미지 첨부) 이후 양쪽 창에서 paste/render 가 잠재적으로 깨져있던 회귀. 사용자가 dogfood 중 발견.
+
+### 게이트
+
+- 단위 750 PASS (CSP meta tag 만 변경 — 코드 path 영향 없음)
+- typecheck 0 errors
+- 신규 npm dependency 0
+
+### 업그레이드
+
+v0.3.10 인스톨러 위에 v0.3.11 인스톨러를 같은 위치에 실행하면 in-place 업그레이드. 데이터/마이그레이션 변경 없음.
+
+## [0.3.10] — 2026-05-12
+
+macOS fullscreen 환경에서 QuickCapture 핫키 (Cmd+Shift+J) 가 작동하지만 강제로 홈 데스크탑으로 Space 전환 후 표시되던 버그 fix.
+
+### 수정
+
+- **macOS fullscreen Space 위에 QuickCapture 표시 (P1).** 기본 BrowserWindow 는 첫 생성된 Space (홈 데스크탑) 에만 표시 → 사용자가 다른 앱 fullscreen 중에 핫키 누르면 macOS 가 강제로 Space 전환 → 사용자 흐름 단절. `quickCaptureWindow.ts` 에 darwin 분기 추가:
+  - `type: 'panel'` — fullscreen Space 위에 floating 가능한 macOS native panel
+  - `setAlwaysOnTop(true, 'screen-saver')` — fullscreen app 위에 띄울 수 있는 가장 높은 level
+  - `setVisibleOnAllWorkspaces(true, { visibleOnFullScreen: true })` — 현재 Space (fullscreen 포함) 에 함께 표시, Space 전환 차단
+
+Windows / Linux 동작은 변경 없음 (darwin 분기만).
+
+### 게이트
+
+- 단위 750 PASS (변경 없음 — main window 코드는 단위 테스트 대상 아님)
+- typecheck 0 errors (src)
+- 신규 npm dependency 0
+- macOS 사용자 수동 검증 완료
+
+### 업그레이드
+
+v0.3.9 인스톨러 위에 v0.3.10 인스톨러를 같은 위치에 실행하면 in-place 업그레이드. 데이터/마이그레이션 변경 없음.
+
+## [0.3.9] — 2026-05-11
+
+v0.3.8 audit 의 미수정 edge case 3건 완료. AI 처리 흐름의 사용자 unblock path + FTS5 query 안전성.
+
+### 수정
+
+- **`ai_status='pending'` 노트 cancel UI 부재 (P1).** Ollama 끊김 / 무한 pending 상태에서 사용자가 빠져나오는 path 가 없었음. NoteCard 의 pending 표시 옆에 "건너뛰기" 버튼 추가 → `inboxApi.cancelPending(id)` → `repo.cancelPending`: `ai_status='disabled'` + `pending_jobs` DELETE. raw_text 는 보존. pushNoteUpdated emit 으로 renderer 자동 sync.
+- **`ai_status='failed'` 노트 per-note 재시도 UI 부재 (P2).** 이전엔 FailedBanner 의 일괄 재시도만 가능. NoteCard 의 failed 표시 옆에 "재시도" 버튼 추가 → `inboxApi.retryOneFailed(id)` → `repo.retryOneFailed`: failed → pending + `pending_jobs` INSERT + worker enqueue. pushNoteUpdated emit.
+- **FTS5 query escape 불완전 (P2).** `sanitizeFtsQuery` 의 special chars regex 가 `["*():]` 만 처리 → backtick/dash/caret 미escape 로 일부 입력이 FTS5 parser throw 야기. `["*():`^\-]` 로 확장. 한국어 사용자가 의도 없이 입력할 가능성 높은 punctuation 까지 안전 처리.
+
+### 미수정 (의도)
+
+- **동시 편집 race (P2).** EditableField 가 이미 `editing=true` 중 value prop 변경을 무시하는 guard 보유. 사용자 입력은 보존됨 (last-write-wins). 추가 코드 불필요.
+
+### 게이트
+
+- 단위 745 → **750 PASS** (+5: repo retryOneFailed 2 + cancelPending 2 + FTS sanitize 1)
+- typecheck 0 errors (src)
+- 신규 npm dependency 0
+
+### 업그레이드
+
+v0.3.8 인스톨러 위에 v0.3.9 인스톨러를 같은 위치에 실행하면 in-place 업그레이드. 데이터/마이그레이션 변경 없음.
+
+## [0.3.8] — 2026-05-11
+
+전수 audit 후 발견된 사용자 상호작용 hole 8건 일괄 hotfix. 핵심은 (1) push-based status 동기화 root fix, (2) modal Escape affordance 통일, (3) IPC 실패 resilience.
+
+### 수정
+
+- **`inbox:set-status` IPC 가 `pushNoteUpdated` emit 안 함 (root fix).** 이전엔 setStatus 후 counts/list/search 가 모두 stale → 호출처마다 `refreshMeta()` 명시 호출이 필요했음 (v0.3.5 워크어라운드). 이제 IPC 핸들러가 `repo.findById()` 후 `pushNoteUpdated` 호출. renderer 의 `onNoteUpdated` 콜백 1개 path 로 모든 status 전이가 일관 갱신.
+- **`upsertNote` 가 current view 무시 → 잘못된 status 노트 잔류.** 이전엔 trashed 외 모든 status 를 `notes` 에 누적 → 사용자가 inbox 에서 완료로 옮긴 노트가 list 에 잔류. v0.3.8 부터 `viewStatus` (inbox→active, completed→completed, archived→archived) 와 매칭되는 status 만 유지. `searchResults` 도 동일 패턴.
+- **`upsertNote` 의 trash 판정을 `deletedAt` → `status='trashed'` 로 전환.** m004 이후 status 가 single source of truth, deletedAt 은 backward-compat mirror. sync conflict 후 두 컬럼 불일치 가능성 대비.
+- **`restoreNote` 가 status 도 'active' 로 갱신.** 이전엔 `deletedAt: null` 만 clear → upsertNote 가 status='trashed' 그대로 라 여전히 trashNotes 에 잔류.
+- **OnboardingWizard close path 부재.** IPC 실패 시 무한 wizard 잠금 → `try/catch + setBusy/error state + "지금 건너뛰기" 버튼 + Escape` 추가. 첫 launch 사용자 막힘 회피.
+- **Modal Escape key dismiss 통일.** `MoveStatusModal` / `RevisionHistoryModal` / `ConflictModal` / `SyncHelpModal` / `OnboardingWizard` 모두 `keydown` listener 추가. MoveStatusModal 은 overlay 클릭 close 도 추가 (다른 modal 들은 이미 외부 클릭 지원).
+- **`store.ts` async 함수 error-resilient.** `loadInitial` / `loadByView` / `searchNotes` / `loadReview` / `refreshMeta` 가 IPC throw 시 try/catch 로 감싸 무한 loading / stale data 회피. loadInitial 은 catch 시 `loading: false`, loadByView 는 빈 list, searchNotes 는 빈 결과, loadReview 는 빈 aggregate 로 graceful fallback.
+
+### 갱신
+
+- **NoteCard 의 명시적 `refreshMeta` 호출 보존** — onNoteUpdated path 가 이미 refreshMeta 호출하므로 redundant 지만 backup 으로 유지 (2번 fetch 만 발생, 무해).
+
+### 게이트
+
+- 단위 739 → **745 PASS** (+6: view-aware upsertNote 3 + setStatus push emit 1 + Modal Escape 1 + Modal overlay 클릭 1)
+- typecheck 0 errors (src)
+- 신규 npm dependency 0
+
+### 업그레이드
+
+v0.3.7 인스톨러 위에 v0.3.8 인스톨러를 같은 위치에 실행하면 in-place 업그레이드. 데이터/마이그레이션 변경 없음.
+
+### 미수정 (낮은 우선순위 / 별도 작업)
+
+- ai_status='pending' 노트 cancel UI (P1, 별도 spec 필요)
+- ai_status='failed' 노트 per-note 재시도 UI (P2)
+- FTS5 query escape (P2, 확인 필요)
+- 동시 편집 race condition (P2)
+
+## [0.3.7] — 2026-05-11
+
+`MoveStatusModal` 의 button hardcode 로 인해 완료/보관/휴지통 노트가 inbox 로 돌아올 수 없던 버그 fix. v0.2.9 Cut B 부터 존재한 잠재 결함 (dropdown 의 `possibleTargets` 필터가 modal 까지 흐르지 못함).
+
+### 수정
+
+- **완료/보관/휴지통 노트의 Inbox 복원 path 부재.** `MoveStatusModal` 이 `완료/보관/휴지통` 3 button hardcode 라 currentStatus 외 3 status 만 동적으로 노출해야 한다는 의도가 누락. `currentStatus: NoteStatus` prop 추가 + 4 status 중 current 제외 동적 render. NoteCard 가 `local.status` 전달.
+- **status label 일관성** — `statusLabel('active')` 가 '활성' 이었으나 헤더 탭 표기는 'Inbox'. modal button + AI 추천 텍스트 양쪽 모두 'Inbox' 로 통일.
+
+### 게이트
+
+- 단위 736 → **739 PASS** (+3: completed/archived/trashed currentStatus button list 검증)
+- typecheck 0 errors (src)
+- 신규 npm dependency 0
+
+### 업그레이드
+
+v0.3.6 인스톨러 위에 v0.3.7 인스톨러를 같은 위치에 실행하면 in-place 업그레이드. 데이터/마이그레이션 변경 없음.
+
+## [0.3.6] — 2026-05-11
+
+v0.3.5 의 이동 dropdown 단순화가 사용자 의도와 어긋난 점 정정. 이동 modal (사유 + AI 자동 분류 + 수동 status 선택) 은 보존해야 하는 핵심 UX 였음.
+
+### 수정
+
+- **이동 dropdown → 단일 "이동" 버튼 + `MoveStatusModal` 복원.** v0.3.5 에서 dropdown 항목 클릭 = 즉시 setStatus 로 단순화한 path 를 되돌림. 사용자 의도는 dropdown 의 목적지 중복 (modal 도 목적지 묻기) 제거였지, modal 자체 제거가 아니었음. 단일 "이동" 버튼 → modal → 사유 입력 + AI 자동 분류 + 수동 status 선택 path 로 통일.
+- **`MoveStatusModal.tsx` + 테스트 6 case 복원** — v0.3.5 에서 dead code 로 판단해 삭제했으나 다시 mount 됨. statusLabel 헬퍼 위치는 modal 내부로 회귀 (orphan `statusLabel.ts` 제거).
+- **이동 후 `refreshMeta()` 호출 유지** — v0.3.5 D1 fix (setStatus IPC 가 pushNoteUpdated emit 안 함 → 헤더 탭 count stale) 는 modal `onMoved` callback path 에서도 동일하게 트리거.
+
+### 게이트
+
+- 단위 734 → **736 PASS** (NoteCard 이동 case 3 → 2 + MoveStatusModal 6 복원)
+- typecheck 0 errors (src)
+- 신규 npm dependency 0
+
+### 업그레이드
+
+v0.3.5 인스톨러 위에 v0.3.6 인스톨러를 같은 위치에 실행하면 in-place 업그레이드. 데이터/마이그레이션 변경 없음.
+
+## [0.3.5] — 2026-05-11
+
+v0.3.4 까지 누적된 dogfood UX 결함 7건 hotfix. 사용자가 막혔던 inbox/회고/이동 3건 + 그 부류의 동반 갭 4건. 데이터/마이그레이션 변경 없음 (스키마 v8 그대로).
+
+### 수정
+
+- **Inbox 탭 진입 실패: 다른 보관함에서 inbox 로 못 돌아옴.** `setView('inbox')` 가 reload 를 호출 안 해서 `notes` state 가 이전 view 의 status 로 stale. `loadByView` 시그니처에 `'inbox' → 'active'` 매핑 추가 + setView 의 reload 분기에 inbox 포함.
+- **회고 view 탈출 불가.** `ReviewView` 가 App 의 헤더를 우회 (early return) 해서 사용자가 뒤로 갈 길이 없던 문제. `← 돌아가기` 버튼 추가 — 클릭 시 `setView('inbox')`.
+- **이동 dropdown 의 modal 중복 질문.** dropdown 에서 "완료로 이동" 선택해도 `MoveStatusModal` 이 떠서 목적지를 재확인. dropdown 클릭 = `inboxApi.setStatus(id, target, null)` 즉시 호출로 단순화. modal path 자체 제거 (`MoveStatusModal.tsx` + 동반 테스트 삭제, `statusLabel` 헬퍼는 별도 `statusLabel.ts` 로 분리).
+- **이동 후 헤더 탭 count stale.** `setStatus` IPC 가 `pushNoteUpdated` emit 을 안 해서 `refreshMeta` 가 트리거되지 않던 잠재 버그. dropdown 이동 path 끝에 `refreshMeta()` 명시 호출 추가.
+- **View 전환 시 검색/태그 필터 잔류.** `setView` 가 `searchResults`/`searchQuery`/`tagFilter` 를 reset 안 해서 이전 view 의 필터가 완료/보관/휴지통/회고에 잘못 적용. 한 번에 reset.
+- **Inbox 첫 로드와 탭 reload 결과 불일치.** `loadInitial` 이 `listNotes()` (= `deleted_at IS NULL` = active+completed+archived 혼재) 사용 → 헤더 inbox count (active 만) 와 list 불일치. `listByStatus('active', limit:50)` 로 통일.
+- **AI 배너가 completed/archived 탭에서도 노출.** OllamaBanner/PendingBanner/FailedBanner/ExpiryBanner/RecallBanner/RecoveryToast 가 `!showTrash` 만 체크해서 active 무관 컨텍스트에서도 그림. `view === 'inbox'` 분기로 한정.
+
+### 갱신
+
+- **이동 dropdown UX** — 메뉴 열린 상태에서 외부 클릭 / Escape 로 닫힘 (mousedown + keydown listener, useEffect 로 menuOpen=true 일 때만 활성).
+
+### 게이트
+
+- 단위 738 → **734 PASS** (MoveStatusModal 6 case 삭제 + NoteCard 메뉴 case 1 → 3 (직접 이동/외부 클릭/Escape) 로 재구성)
+- typecheck 0 errors (src)
+- 신규 npm dependency 0
+
+### 업그레이드
+
+v0.3.4 인스톨러 위에 v0.3.5 인스톨러를 같은 위치에 실행하면 in-place 업그레이드. 데이터/마이그레이션 변경 없음.
+
+## [0.3.4] — 2026-05-11
+
+v0.3.0 Cut E (양방향 sync) dogfood 의 결과로, 사용자가 conflict 시나리오에 막힌 순간 도움받을 곳이 부재한 갭을 메운 cut. 3 표면 (in-app modal + ConflictModal inline + README) 통합 도움말. PR #33 머지.
+
+### 신규
+
+- **`SyncHelpModal` (4 anchor 섹션)** — 설정 → 동기화 저장소 → "도움말" 버튼 또는 ConflictModal 의 "자세히 보기 →" 링크에서 진입. `#main-conflict` (편집/편집·삭제/편집·AI 결과 충돌 결정 트리) / `#auto` (fetch+rebase·첫 sync·push 거부·자동 주기) / `#silent` (NTP·동시 수정·자동 sync 실패 silent) / `#setup` (URL SSH/HTTPS 형식·잘못된 `git@https://` 사례·인증 helper·연결 테스트 실패 troubleshoot·URL 재설정).
+
+### 갱신
+
+- **`ConflictModal` inline 설명** — 각 conflict row 의 "내 것 사용" / "원격 사용" 의미를 1-2 줄 인라인 안내 + (옵션) "자세히 보기 →" 링크 (onOpenHelp callback). 기존 caller backward-compatible (optional prop).
+- **`SyncSection` 도움말 버튼** — URL row 마지막에 추가. busy (저장/테스트/sync 진행) 중에도 도움말 reachable (read-only).
+- **`README` 동기화 섹션 통째 재작성** — stale "원격 백업 (F6-L2)" (v0.2.1 MVP, 트레이 "지금 동기화" + 수동 `git init` 안내) → "동기화 (Git, F21 Cut E)". 일회 설정 / 일상 사용 / 충돌 해결 (3 케이스) / Silent risk / Troubleshoot. in-app SyncHelpModal 과 동일 정보 산문체.
+
+### 게이트
+
+- 단위 727 → **738 PASS** (+11): SyncHelpModal 7 + ConflictModal 회귀 3 + SyncSection 회귀 1
+- typecheck 0 errors
+- 신규 npm dependency 0
+
+### 후속 (deferred)
+
+- ESC key handler (현재 SyncHelpModal / ConflictModal 모두 X + overlay 만, 프로젝트 패턴 정합. 도입 시 양쪽 동시).
+- 1주 dogfood soak 후 도움말 텍스트 정합성 1차 갱신 (실제 사용자 경험과 어긋난 부분 보강).
+
+### 업그레이드
+
+v0.3.3 인스톨러 위에 v0.3.4 인스톨러를 같은 위치에 실행하면 in-place 업그레이드. 데이터/마이그레이션 변경 없음 (스키마 v8 그대로).
+
+## [0.3.3] — 2026-05-10
+
+v0.3.0 Cut E (양방향 sync) dogfood 첫 시도 중 발견된 sync 설정 ENOENT 버그 hotfix.
+
+### 수정
+
+- **Sync 설정 첫 저장 실패 (git init ENOENT)**: 설정 → 동기화 저장소에서 URL 입력 후 "저장" 클릭 시 `git init failed: fatal: cannot change to '<profileDir>/sync': No such file or directory` 로 실패하던 문제. `settings:configure-sync` IPC 핸들러가 `git -C <syncDir> init` 호출 전에 syncDir 디렉토리를 생성하지 않아 git 이 chdir 단계에서 죽음. `SyncService.runSync()` 의 동일 패턴 (`mkdir(syncDir, { recursive: true })`) 을 핸들러에도 추가. 결과적으로 "연결 테스트" 버튼이 영영 활성화되지 않던 연쇄 증상 (저장 성공 시에만 url state 채워지고 버튼 enable) 도 자동 해소.
+
+### 게이트
+
+- 단위 테스트: `tests/unit/sync-ipc.test.ts` 18 (mkdir 호출 순서 회귀 1 추가)
+- typecheck: 0 errors
+- 신규 npm dependency: 0
+
+### 업그레이드
+
+v0.3.2 인스톨러 위에 v0.3.3 인스톨러를 같은 위치에 실행하면 in-place 업그레이드. 데이터/마이그레이션 변경 없음 (스키마 v8 그대로).
+
 ## [0.2.2] — 2026-04-26
 
 v0.2.1 dogfood 중 발견된 F7 (Due Date 합성 표현) + Quick Capture 스크롤 버그를 묶은 패치.

README.md

@@ -190,37 +190,58 @@ inkling.md         원본 제품 브리프 v1.4
 
 ---
 
-## 원격 백업 (선택, F6-L2)
+## 동기화 (Git, F21 Cut E)
 
-Inkling 데이터를 사적 git 원격에 백업하려면 한 번만 설정하면 된다. 인코딩된 형식이 아니라 평문 마크다운(F5 export 형식)으로 저장되니, **반드시 비공개 repo** 를 사용한다.
+Inkling 데이터를 사적 git 원격으로 양방향 동기화 (Mac ↔ Windows 등). 평문 마크다운(F5 export 형식)으로 저장되니 **반드시 비공개 repo** 를 사용한다.
+
+상세 도움말은 앱 내 설정 → 동기화 저장소 → "도움말" 버튼 (4 섹션 modal) 참조. 본 섹션은 setup + 주요 시나리오 요약.
 
 ### 일회 설정
 
-```bash
-# 1. 빈 사적 repo 생성 (예: gitea, GitHub private)
+1. 빈 사적 repo 생성 (Gitea / GitHub private)
+2. 앱 → 설정 → 동기화 저장소 → URL 입력 → "저장"
+3. "연결 테스트" 클릭해 인증 / 네트워크 확인
+4. 자동 sync 사용 토글 + interval (기본 30분) 확인
 
-# 2. 데이터 디렉터리에 git 초기화 + 원격 등록
-cd "%APPDATA%\Inkling\Inkling\profiles\default\sync"   # Windows
-git init
-git remote add origin https://your-host/owner/inkling-data.git
-git fetch origin || true   # 빈 repo 면 무시
+URL 형식 (둘 중 하나):
 
-# 3. 자격증명 설정 (Windows Credential Manager 자동 / 또는 token 임베드 URL)
+- SSH: `git@host:user/repo.git`
+- HTTPS: `https://host/user/repo.git`
 
-# 4. 첫 동기화: 트레이 → "지금 동기화"
-```
+`git@https://...` 같은 혼합 형식은 거부된다.
 
-처음 sync 시 SyncService 가 `<profileDir>/sync/` 안에 F5 export 트리(notes/, media/, index.jsonl, manifest.json)를 덮어쓰고 `git add -A && git commit && git push -u origin <branch>` 를 자동 수행.
+### 일상 사용
 
-### 사용
+- 자동 sync: 설정한 interval 마다 + 앱 종료 시 1회
+- 수동 sync: 트레이 → "지금 동기화"
+- 충돌 발생 시 트레이 토스트 + 설정 페이지의 "충돌 해결…" 버튼 → ConflictModal
 
-- 트레이 → "지금 동기화" 로 수동 트리거
-- 앱 종료 시 자동 1회 (sync dir 이 설정된 경우만)
-- 변경 없으면 토스트 "변경 사항 없음", 변경 있으면 "동기화 완료"
+### 충돌 해결 (ConflictModal)
 
-설정이 안 됐으면 트레이 토스트로 안내. 한 번 설정하면 이후 push 는 OS credential helper 가 자동 처리.
+같은 노트를 두 기기에서 동시에 수정하면 path 별 결정 (내 것 / 원격) 을 받는다.
 
-데이터 라이프사이클 측면에서 F6-L1 (로컬 스냅샷, 자동) + F5/F6-L3 (수동 export/import) + F6-L2 (원격 git, 반자동) 3-layer 구조의 마지막 layer.
+- **내 것 사용**: 이 기기의 변경을 보존, 원격 변경을 폐기
+- **원격 사용**: 원격 변경을 가져오고, 이 기기의 변경을 폐기
+
+3 케이스:
+
+1. 편집/편집 — 양 텍스트 비교 후 더 새롭고 완전한 쪽 선택. 둘 다 보존하려면 한쪽 선택 + 사후 수동 병합 ('both' 미지원)
+2. 삭제/편집 — 삭제가 의도였으면 원격 사용 (trash 측), 수정이 더 중요하면 내 것 사용 (편집 측 = trash 취소)
+3. AI 결과 충돌 — 한쪽 선택 후 AI 재실행 권장
+
+### Silent risk
+
+- **시계 어긋남 (NTP)**: 양 기기 시계가 다르면 timestamp merge 가 잘못된 결과를 낼 수 있음. NTP 동기화 끄지 말 것
+- **두 기기 동시 수정 회피**: 같은 노트를 동시에 수정하면 conflict 가 잦아짐
+- **자동 sync 실패 silent**: 주기적 sync 실패 시 토스트 안 뜸. 마지막 sync 시각 / 결과는 설정 페이지에서 확인
+
+### Troubleshoot
+
+- **"연결 테스트" 실패** — 네트워크 (브라우저로 호스트 접속) / 인증 (SSH key 또는 token) / URL 오타 점검
+- **인증 실패 (push 안 됨)** — SSH 는 public key 등록 점검, HTTPS 는 OS credential helper (Windows Credential Manager / macOS Keychain) 의 저장 token 점검
+- **URL 변경** — 설정 페이지에서 새 URL 입력 → 저장 (`git remote set-url origin` 자동 처리)
+
+데이터 라이프사이클: F6-L1 (로컬 스냅샷, 자동) + F5/F6-L3 (수동 export/import) + F21 Cut E (양방향 git sync) 3-layer 구조.
 
 ---
 

docs/superpowers/plans/2026-05-10-sync-help.md

@@ -0,0 +1,720 @@
+# Sync 도움말 Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** v0.3.0 Cut E 양방향 sync 의 사용자 도움말을 in-app modal + ConflictModal inline + README 3 표면에 도입. 다기기 dogfood 의 conflict 시나리오에 막힌 순간 결정 트리 / 자동 처리 동작 / silent risk / setup 인증 troubleshoot 4 카테고리를 즉시 찾을 수 있게.
+
+**Architecture:** 신규 `SyncHelpModal` 컴포넌트 (4 anchor 섹션, ConflictModal 패턴 재사용) + ConflictModal 의 local/remote 옵션 inline 설명 + "자세히 보기" 링크 (`onOpenHelp` callback) + SyncSection 의 "도움말" 버튼이 modal mount/unmount 관리. README 의 stale "원격 백업 (F6-L2)" 섹션은 "동기화 (Git)" 로 통째 재작성.
+
+**Tech Stack:** React 18 / TypeScript / vitest + @testing-library/react / electron-vite. 기존 ConflictModal 패턴 정합 (overlay + stopPropagation + 인라인 style object).
+
+**Spec:** `docs/superpowers/specs/2026-05-10-sync-help-design.md`
+
+---
+
+## File Structure
+
+**신규**:
+
+- `src/renderer/inbox/components/SyncHelpModal.tsx` — 신규 modal, 4 anchor 섹션 (`#main-conflict`, `#auto`, `#silent`, `#setup`)
+- `tests/unit/SyncHelpModal.test.tsx` — 렌더링 + close 회귀
+
+**수정**:
+
+- `src/renderer/inbox/components/ConflictModal.tsx` — `onOpenHelp` prop 추가, 각 옵션 inline 설명 + "자세히 보기" 링크
+- `tests/unit/ConflictModal.test.tsx` — inline 설명 + 링크 회귀 추가
+- `src/renderer/inbox/components/settings/SyncSection.tsx` — "도움말" 버튼 + `showHelp` state + `SyncHelpModal` mount + `ConflictModal` 의 `onOpenHelp` wiring
+- `tests/unit/SyncSection.test.tsx` — 도움말 버튼 → modal open 회귀
+- `README.md` line 193-223 — "원격 백업 (F6-L2)" 섹션 통째 재작성
+
+---
+
+## Task 1: SyncHelpModal 컴포넌트 (4 anchor 섹션 + close 동작)
+
+**Files:**
+
+- Create: `src/renderer/inbox/components/SyncHelpModal.tsx`
+- Test: `tests/unit/SyncHelpModal.test.tsx`
+
+- [ ] **Step 1: Write the failing test**
+
+`tests/unit/SyncHelpModal.test.tsx` 신규 작성:
+
+```tsx
+// @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 React from 'react';
+import { SyncHelpModal } from '../../src/renderer/inbox/components/SyncHelpModal';
+
+describe('SyncHelpModal', () => {
+  beforeEach(() => {
+    cleanup();
+  });
+
+  it('4 섹션 헤더 렌더링', () => {
+    render(<SyncHelpModal onClose={() => {}} />);
+    expect(screen.getByRole('heading', { name: /충돌 해결/ })).toBeInTheDocument();
+    expect(screen.getByRole('heading', { name: /자동 처리/ })).toBeInTheDocument();
+    expect(screen.getByRole('heading', { name: /조용히 잘못될 수 있는/ })).toBeInTheDocument();
+    expect(screen.getByRole('heading', { name: /Setup/ })).toBeInTheDocument();
+  });
+
+  it('각 섹션이 anchor id 보유', () => {
+    const { container } = render(<SyncHelpModal onClose={() => {}} />);
+    expect(container.querySelector('#main-conflict')).not.toBeNull();
+    expect(container.querySelector('#auto')).not.toBeNull();
+    expect(container.querySelector('#silent')).not.toBeNull();
+    expect(container.querySelector('#setup')).not.toBeNull();
+  });
+
+  it('초기 anchor prop 으로 해당 섹션 scrollIntoView 호출', () => {
+    const scrollSpy = vi.fn();
+    Element.prototype.scrollIntoView = scrollSpy;
+    render(<SyncHelpModal onClose={() => {}} initialAnchor="main-conflict" />);
+    expect(scrollSpy).toHaveBeenCalled();
+  });
+
+  it('X 버튼 클릭 → onClose 호출', () => {
+    const onClose = vi.fn();
+    render(<SyncHelpModal onClose={onClose} />);
+    fireEvent.click(screen.getByRole('button', { name: /닫기/ }));
+    expect(onClose).toHaveBeenCalled();
+  });
+
+  it('overlay 클릭 → onClose 호출', () => {
+    const onClose = vi.fn();
+    const { container } = render(<SyncHelpModal onClose={onClose} />);
+    const overlay = container.firstChild as HTMLElement;
+    fireEvent.click(overlay);
+    expect(onClose).toHaveBeenCalled();
+  });
+
+  it('modal body 클릭 → onClose 호출 X (stopPropagation)', () => {
+    const onClose = vi.fn();
+    render(<SyncHelpModal onClose={onClose} />);
+    fireEvent.click(screen.getByRole('heading', { name: /충돌 해결/ }));
+    expect(onClose).not.toHaveBeenCalled();
+  });
+
+  it('주요 시나리오 키워드 본문 포함 (회귀)', () => {
+    render(<SyncHelpModal onClose={() => {}} />);
+    // 메인 conflict 3 케이스
+    expect(screen.getByText(/편집\/편집/)).toBeInTheDocument();
+    expect(screen.getByText(/삭제\/편집/)).toBeInTheDocument();
+    expect(screen.getByText(/AI 결과 충돌/)).toBeInTheDocument();
+    // setup 의 잘못된 URL 형식 사례
+    expect(screen.getByText(/git@https:\/\//)).toBeInTheDocument();
+  });
+});
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+```bash
+cd C:\Users\rlaxo\inkling
+npx vitest run tests/unit/SyncHelpModal.test.tsx
+```
+
+Expected: FAIL (module not found — `SyncHelpModal` 미존재)
+
+- [ ] **Step 3: Implement SyncHelpModal**
+
+`src/renderer/inbox/components/SyncHelpModal.tsx` 신규:
+
+```tsx
+import React, { useEffect, useRef } from 'react';
+
+export type SyncHelpAnchor = 'main-conflict' | 'auto' | 'silent' | 'setup';
+
+interface Props {
+  onClose: () => void;
+  initialAnchor?: SyncHelpAnchor;
+}
+
+const overlayStyle: React.CSSProperties = {
+  position: 'fixed', top: 0, left: 0, width: '100vw', height: '100vh',
+  background: 'rgba(0,0,0,0.4)', display: 'flex', alignItems: 'center',
+  justifyContent: 'center', zIndex: 110
+};
+
+const modalStyle: React.CSSProperties = {
+  background: '#fff', borderRadius: 8, padding: 20, width: 640,
+  maxHeight: '80vh', overflow: 'auto', boxShadow: '0 4px 16px rgba(0,0,0,0.2)'
+};
+
+const sectionStyle: React.CSSProperties = {
+  marginTop: 18, paddingTop: 12, borderTop: '1px solid #eee'
+};
+
+const h4Style: React.CSSProperties = { fontSize: 14, margin: '0 0 8px 0' };
+const pStyle: React.CSSProperties = { fontSize: 12, color: '#444', lineHeight: 1.6, margin: '4px 0' };
+const liStyle: React.CSSProperties = { fontSize: 12, color: '#444', lineHeight: 1.6, marginBottom: 4 };
+const codeStyle: React.CSSProperties = { background: '#f4f4f4', padding: '1px 4px', borderRadius: 3, fontSize: 11 };
+
+export function SyncHelpModal({ onClose, initialAnchor }: Props): React.ReactElement {
+  const bodyRef = useRef<HTMLDivElement>(null);
+
+  useEffect(() => {
+    if (!initialAnchor) return;
+    const el = bodyRef.current?.querySelector(`#${initialAnchor}`);
+    if (el) el.scrollIntoView({ behavior: 'auto', block: 'start' });
+  }, [initialAnchor]);
+
+  return (
+    <div style={overlayStyle} onClick={onClose}>
+      <div ref={bodyRef} style={modalStyle} onClick={(e) => e.stopPropagation()}>
+        <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>
+          <h3 style={{ margin: 0, fontSize: 16 }}>동기화 도움말</h3>
+          <button onClick={onClose} aria-label="닫기" style={{ background: 'none', border: 'none', fontSize: 18, cursor: 'pointer', color: '#888' }}>×</button>
+        </div>
+
+        <section id="main-conflict" style={sectionStyle}>
+          <h4 style={h4Style}>1. 충돌 해결 (메인 시나리오)</h4>
+          <p style={pStyle}>같은 노트를 두 기기에서 동시에 수정하면 충돌이 발생한다. "충돌 해결…" 버튼이 활성화되면 ConflictModal 이 열려 path 별 결정 (내 것 사용 / 원격 사용) 을 받는다.</p>
+
+          <p style={{ ...pStyle, marginTop: 10, fontWeight: 600 }}>편집/편집 — 가장 흔한 경우</p>
+          <ul style={{ paddingLeft: 18, margin: '4px 0' }}>
+            <li style={liStyle}>두 기기에서 같은 노트 본문 수정 → 양 텍스트가 ConflictModal 에 좌우로 나란히 표시</li>
+            <li style={liStyle}>결정 트리: 어느 쪽 변경이 더 새롭고 완전한지 비교 → 더 나은 쪽 선택</li>
+            <li style={liStyle}>둘 다 보존하려면? 현재 'both' 미지원 — 한쪽 선택 후 사후 수동 병합 (다른 쪽 텍스트 메모 → 모달 닫고 노트 편집)</li>
+          </ul>
+
+          <p style={{ ...pStyle, marginTop: 10, fontWeight: 600 }}>삭제/편집</p>
+          <ul style={{ paddingLeft: 18, margin: '4px 0' }}>
+            <li style={liStyle}>한쪽에서 trash 처리, 다른 쪽에서 같은 노트 본문 수정</li>
+            <li style={liStyle}>"삭제가 의도였다" → 원격 사용 (trash 측 적용)</li>
+            <li style={liStyle}>"수정이 더 중요" → 내 것 사용 (편집 측 적용 = trash 취소)</li>
+          </ul>
+
+          <p style={{ ...pStyle, marginTop: 10, fontWeight: 600 }}>AI 결과 충돌</p>
+          <ul style={{ paddingLeft: 18, margin: '4px 0' }}>
+            <li style={liStyle}>양 기기에서 AI 자동 처리 결과 (태그 / 주제 / 요약) 가 다름</li>
+            <li style={liStyle}>대부분 어느 쪽이든 무관 → 한쪽 선택 후 AI 재실행 권장 (가장 최신 모델 결과로 통일)</li>
+          </ul>
+        </section>
+
+        <section id="auto" style={sectionStyle}>
+          <h4 style={h4Style}>2. 자동 처리 (내가 안 해도 되는 일)</h4>
+          <ul style={{ paddingLeft: 18, margin: '4px 0' }}>
+            <li style={liStyle}><b>fetch + rebase</b>: sync 시작 시 원격 변경을 가져와 내 변경 위에 다시 쌓음 (linear history). conflict 없으면 자동 진행</li>
+            <li style={liStyle}><b>첫 sync 순서</b>: 빈 원격에는 어느 기기든 먼저 push 가능. 두 번째 기기는 fetch 후 자동 rebase</li>
+            <li style={liStyle}><b>push 거부 (non-fast-forward)</b>: 다른 기기가 먼저 push 했어도 자동 fetch + rebase + 재시도. 사용자 개입은 rebase conflict 발생 시에만</li>
+            <li style={liStyle}><b>자동 sync 주기</b>: 기본 30분 (설정에서 변경). 앱 종료 시 자동 1회 추가</li>
+          </ul>
+        </section>
+
+        <section id="silent" style={sectionStyle}>
+          <h4 style={h4Style}>3. 조용히 잘못될 수 있는 케이스 (silent risk)</h4>
+          <ul style={{ paddingLeft: 18, margin: '4px 0' }}>
+            <li style={liStyle}><b>시계 어긋남 (NTP)</b>: 양 기기 시계가 다르면 timestamp 기반 merge 가 잘못된 결과를 낼 수 있음. macOS / Windows 모두 기본 NTP 동기화 켜져 있음 — 수동으로 끄지 말 것</li>
+            <li style={liStyle}><b>두 기기 동시 수정 회피</b>: 같은 노트를 동시에 수정하면 conflict 가 더 자주 발생. 한 기기에서 작업 중이면 다른 기기에서 같은 노트 수정 자제</li>
+            <li style={liStyle}><b>자동 sync 실패 silent</b>: 주기적 sync 실패 시 토스트 안 뜸. 마지막 sync 시각 / 결과는 설정 페이지에서 확인 — 주 1회 점검 권장</li>
+          </ul>
+        </section>
+
+        <section id="setup" style={sectionStyle}>
+          <h4 style={h4Style}>4. Setup / 인증 (troubleshoot)</h4>
+          <p style={{ ...pStyle, fontWeight: 600 }}>URL 형식 (둘 중 하나)</p>
+          <ul style={{ paddingLeft: 18, margin: '4px 0' }}>
+            <li style={liStyle}>SSH: <code style={codeStyle}>git@host:user/repo.git</code></li>
+            <li style={liStyle}>HTTPS: <code style={codeStyle}>https://host/user/repo.git</code></li>
+            <li style={liStyle}>잘못된 형식: <code style={codeStyle}>git@https://...</code> 같은 혼합 형식 ✗</li>
+          </ul>
+
+          <p style={{ ...pStyle, fontWeight: 600, marginTop: 10 }}>인증</p>
+          <ul style={{ paddingLeft: 18, margin: '4px 0' }}>
+            <li style={liStyle}>SSH: 기기에 SSH key 등록 + 원격에 public key 추가</li>
+            <li style={liStyle}>HTTPS: OS credential helper (Windows Credential Manager / macOS Keychain) 가 첫 push 시 token 입력받아 저장. 매 push 마다 재입력 X</li>
+          </ul>
+
+          <p style={{ ...pStyle, fontWeight: 600, marginTop: 10 }}>"연결 테스트" 실패 시</p>
+          <ul style={{ paddingLeft: 18, margin: '4px 0' }}>
+            <li style={liStyle}>네트워크: 원격 host 에 브라우저로 접속해 응답 확인</li>
+            <li style={liStyle}>인증: 위 인증 절차 점검</li>
+            <li style={liStyle}>URL: 형식 (SSH/HTTPS) + 오타 점검</li>
+          </ul>
+
+          <p style={{ ...pStyle, fontWeight: 600, marginTop: 10 }}>재설정</p>
+          <ul style={{ paddingLeft: 18, margin: '4px 0' }}>
+            <li style={liStyle}>URL 변경 시 설정 → 동기화 저장소에서 새 URL 입력 → 저장. 내부적으로 <code style={codeStyle}>git remote set-url origin</code> 자동 처리</li>
+          </ul>
+        </section>
+      </div>
+    </div>
+  );
+}
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+```bash
+npx vitest run tests/unit/SyncHelpModal.test.tsx
+```
+
+Expected: 7/7 PASS
+
+- [ ] **Step 5: typecheck**
+
+```bash
+npx tsc --noEmit
+```
+
+Expected: 0 errors
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add src/renderer/inbox/components/SyncHelpModal.tsx tests/unit/SyncHelpModal.test.tsx
+git commit -m "feat(sync-help): SyncHelpModal 4 anchor 섹션 (메인 conflict / 자동 / silent / setup)"
+```
+
+---
+
+## Task 2: ConflictModal 갱신 — inline 설명 + "자세히 보기" 링크
+
+**Files:**
+
+- Modify: `src/renderer/inbox/components/ConflictModal.tsx`
+- Modify: `tests/unit/ConflictModal.test.tsx`
+
+- [ ] **Step 1: Update test**
+
+`tests/unit/ConflictModal.test.tsx` 의 마지막에 두 케이스 추가 (기존 3 케이스 유지). 또한 mock 시그니처에 `onOpenHelp` 추가.
+
+기존 코드:
+
+```tsx
+import { ConflictModal } from '../../src/renderer/inbox/components/ConflictModal';
+
+describe('ConflictModal', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    cleanup();
+    mockListConflicts.mockResolvedValue([
+      { path: 'notes/n1.md', localText: 'local A', remoteText: 'remote A' },
+      { path: 'notes/n2.md', localText: 'local B', remoteText: 'remote B' }
+    ]);
+    mockResolveConflict.mockResolvedValue({ ok: true });
+  });
+```
+
+기존 3 it 블록은 그대로 (onOpenHelp optional 이라 미수정 호출 type-clean).
+
+신규 2 케이스 추가:
+
+```tsx
+  it('각 conflict row 에 local/remote inline 설명 표시', async () => {
+    render(<ConflictModal onClose={() => {}} onResolved={() => {}} onOpenHelp={() => {}} />);
+    await waitFor(() => screen.getByText(/local A/));
+    // 두 conflict row → inline 설명 2 회씩
+    expect(screen.getAllByText(/이 기기의 변경을 보존/).length).toBeGreaterThanOrEqual(2);
+    expect(screen.getAllByText(/원격의 변경을 가져오고/).length).toBeGreaterThanOrEqual(2);
+  });
+
+  it('"자세히 보기" 클릭 → onOpenHelp("main-conflict") 호출', async () => {
+    const onOpenHelp = vi.fn();
+    render(<ConflictModal onClose={() => {}} onResolved={() => {}} onOpenHelp={onOpenHelp} />);
+    await waitFor(() => screen.getByText(/local A/));
+    const links = screen.getAllByRole('button', { name: /자세히 보기/ });
+    fireEvent.click(links[0]!);
+    expect(onOpenHelp).toHaveBeenCalledWith('main-conflict');
+  });
+
+  it('onOpenHelp 미제공 → "자세히 보기" 링크 미렌더', async () => {
+    render(<ConflictModal onClose={() => {}} onResolved={() => {}} />);
+    await waitFor(() => screen.getByText(/local A/));
+    expect(screen.queryByRole('button', { name: /자세히 보기/ })).toBeNull();
+  });
+});
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+```bash
+npx vitest run tests/unit/ConflictModal.test.tsx
+```
+
+Expected: FAIL — `onOpenHelp` prop 미존재 / inline 설명 미표시 / "자세히 보기" 버튼 없음
+
+- [ ] **Step 3: Update ConflictModal**
+
+`src/renderer/inbox/components/ConflictModal.tsx`:
+
+Props interface 갱신 (`onOpenHelp` 는 **optional** — 없으면 "자세히 보기" 링크 미렌더. caller 가 wiring 하지 않은 환경에서 type-clean):
+
+```tsx
+interface Props {
+  onClose: () => void;
+  onResolved: () => void;
+  onOpenHelp?: (anchor: 'main-conflict' | 'auto' | 'silent' | 'setup') => void;
+}
+```
+
+함수 signature:
+
+```tsx
+export function ConflictModal({ onClose, onResolved, onOpenHelp }: Props): React.ReactElement {
+```
+
+각 conflict row 의 button row 위에 inline 설명 + (조건부) "자세히 보기" 링크 삽입. 기존 button row (`<div style={{ marginTop: 8, ... }}>`) 직전에 추가:
+
+```tsx
+            <div style={{ marginTop: 8, fontSize: 11, color: '#666', lineHeight: 1.5 }}>
+              <div><b>내 것 사용</b>: 이 기기의 변경을 보존하고 원격의 같은 노트 변경을 폐기.</div>
+              <div><b>원격 사용</b>: 원격의 변경을 가져오고 내 변경을 폐기.</div>
+              {onOpenHelp && (
+                <button
+                  onClick={() => onOpenHelp('main-conflict')}
+                  style={{ background: 'none', border: 'none', color: '#0a4b80', cursor: 'pointer', fontSize: 11, padding: 0, marginTop: 2, textDecoration: 'underline' }}
+                >
+                  자세히 보기 →
+                </button>
+              )}
+            </div>
+```
+
+전체 row 변경 후 모습:
+
+```tsx
+        {conflicts.map((c) => (
+          <div key={c.path} style={rowStyle}>
+            <div style={{ fontSize: 12, color: '#888', marginBottom: 6 }}>{c.path}</div>
+            <div style={{ display: 'flex', gap: 12 }}>
+              <div style={{ flex: 1 }}>
+                <div style={{ fontSize: 11, color: '#666', marginBottom: 4 }}>내 기기</div>
+                <pre style={preStyle()}>{c.localText || '(미리보기 없음)'}</pre>
+              </div>
+              <div style={{ flex: 1 }}>
+                <div style={{ fontSize: 11, color: '#666', marginBottom: 4 }}>다른 기기</div>
+                <pre style={preStyle()}>{c.remoteText || '(미리보기 없음)'}</pre>
+              </div>
+            </div>
+            <div style={{ marginTop: 8, fontSize: 11, color: '#666', lineHeight: 1.5 }}>
+              <div><b>내 것 사용</b>: 이 기기의 변경을 보존하고 원격의 같은 노트 변경을 폐기.</div>
+              <div><b>원격 사용</b>: 원격의 변경을 가져오고 내 변경을 폐기.</div>
+              <button
+                onClick={() => onOpenHelp('main-conflict')}
+                style={{ background: 'none', border: 'none', color: '#0a4b80', cursor: 'pointer', fontSize: 11, padding: 0, marginTop: 2, textDecoration: 'underline' }}
+              >
+                자세히 보기 →
+              </button>
+            </div>
+            <div style={{ marginTop: 8, display: 'flex', gap: 8, justifyContent: 'flex-end' }}>
+              <button
+                onClick={() => { void onChoose(c.path, 'local'); }}
+                disabled={busy === c.path}
+                style={chooseBtnStyle('#0a4b80')}
+              >
+                {busy === c.path ? '처리 중…' : '내 것 사용'}
+              </button>
+              <button
+                onClick={() => { void onChoose(c.path, 'remote'); }}
+                disabled={busy === c.path}
+                style={chooseBtnStyle('#236b1a')}
+              >
+                {busy === c.path ? '처리 중…' : '원격 사용'}
+              </button>
+            </div>
+          </div>
+        ))}
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+```bash
+npx vitest run tests/unit/ConflictModal.test.tsx
+```
+
+Expected: 6/6 PASS (기존 3 + 신규 3)
+
+- [ ] **Step 5: typecheck**
+
+```bash
+npx tsc --noEmit
+```
+
+Expected: 0 errors (`onOpenHelp` 가 optional 이라 기존 SyncSection.tsx caller 그대로 type-clean. Task 3 에서 wiring).
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add src/renderer/inbox/components/ConflictModal.tsx tests/unit/ConflictModal.test.tsx
+git commit -m "feat(sync-help): ConflictModal inline 설명 + 자세히 보기 링크 (onOpenHelp prop)"
+```
+
+---
+
+## Task 3: SyncSection wiring — 도움말 버튼 + SyncHelpModal mount + ConflictModal onOpenHelp
+
+**Files:**
+
+- Modify: `src/renderer/inbox/components/settings/SyncSection.tsx`
+- Modify: `tests/unit/SyncSection.test.tsx`
+
+- [ ] **Step 1: Update test**
+
+`tests/unit/SyncSection.test.tsx` 에 추가 (기존 케이스 유지):
+
+```tsx
+  it('도움말 버튼 클릭 → SyncHelpModal open', async () => {
+    render(<SyncSection />);
+    await waitFor(() => screen.getByRole('button', { name: /저장/ }));
+    fireEvent.click(screen.getByRole('button', { name: /^도움말$/ }));
+    await waitFor(() => screen.getByRole('heading', { name: /동기화 도움말/ }));
+    expect(screen.getByRole('heading', { name: /동기화 도움말/ })).toBeInTheDocument();
+  });
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+```bash
+npx vitest run tests/unit/SyncSection.test.tsx
+```
+
+Expected: FAIL — "도움말" 버튼 없음
+
+- [ ] **Step 3: Update SyncSection**
+
+`src/renderer/inbox/components/settings/SyncSection.tsx`:
+
+상단 import 에 추가:
+
+```tsx
+import { SyncHelpModal, type SyncHelpAnchor } from '../SyncHelpModal.js';
+```
+
+state 추가 (`showConflict` 옆):
+
+```tsx
+  const [showHelp, setShowHelp] = useState<{ open: boolean; anchor?: SyncHelpAnchor }>({ open: false });
+```
+
+URL row 의 버튼 영역에 "도움말" 버튼 추가 (연결 테스트 버튼 옆):
+
+```tsx
+        <button onClick={() => setShowHelp({ open: true })} disabled={busy !== null} style={btnStyle()}>
+          도움말
+        </button>
+```
+
+`ConflictModal` 호출에 `onOpenHelp` 추가:
+
+```tsx
+          {showConflict && (
+            <ConflictModal
+              onClose={() => setShowConflict(false)}
+              onResolved={async () => {
+                setStatus(await inboxApi.getSyncStatus());
+              }}
+              onOpenHelp={(anchor) => setShowHelp({ open: true, anchor })}
+            />
+          )}
+```
+
+return 의 마지막 (section close 직전) 에 SyncHelpModal mount 추가:
+
+```tsx
+      {showHelp.open && (
+        <SyncHelpModal
+          onClose={() => setShowHelp({ open: false })}
+          initialAnchor={showHelp.anchor}
+        />
+      )}
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+```bash
+npx vitest run tests/unit/SyncSection.test.tsx tests/unit/ConflictModal.test.tsx tests/unit/SyncHelpModal.test.tsx
+```
+
+Expected: 모두 PASS
+
+- [ ] **Step 5: App.test.tsx / SettingsPage.test.tsx 에서 ConflictModal 깊이 호출 X 회귀 확인**
+
+`tests/unit/App.test.tsx` 와 `tests/unit/SettingsPage.test.tsx` 는 SyncSection 을 mount 하지만 `showConflict=false` default 라 ConflictModal 직접 렌더 X. SyncHelpModal 도 default closed. mock 갱신 불필요.
+
+```bash
+npx vitest run tests/unit/App.test.tsx tests/unit/SettingsPage.test.tsx
+```
+
+Expected: PASS (mock 갱신 없이도 통과)
+
+- [ ] **Step 6: 전체 typecheck + 단위**
+
+```bash
+npx tsc --noEmit && npx vitest run
+```
+
+Expected: 0 errors, 모두 PASS (총 +11 케이스: SyncHelpModal 7 + ConflictModal 회귀 3 + SyncSection 회귀 1, App/SettingsPage 무영향)
+
+- [ ] **Step 7: Commit**
+
+```bash
+git add src/renderer/inbox/components/settings/SyncSection.tsx tests/unit/SyncSection.test.tsx
+git commit -m "feat(sync-help): SyncSection 도움말 버튼 + SyncHelpModal mount + ConflictModal onOpenHelp wiring"
+```
+
+---
+
+## Task 4: README "원격 백업 (F6-L2)" 섹션 통째 재작성 → "동기화 (Git, Cut E)"
+
+**Files:**
+
+- Modify: `README.md` line 193-223
+
+- [ ] **Step 1: 기존 섹션 확인**
+
+```bash
+sed -n '193,223p' README.md
+```
+
+기대 출력: 옛 v0.2.1 MVP 안내 (`cd %APPDATA%\Inkling\...\sync` + 수동 `git init` + 트레이 "지금 동기화"). 본 섹션을 통째 교체.
+
+- [ ] **Step 2: 섹션 교체 (Edit tool 사용)**
+
+기존 텍스트 (line 193-223 전부):
+
+```markdown
+## 원격 백업 (선택, F6-L2)
+
+Inkling 데이터를 사적 git 원격에 백업하려면 한 번만 설정하면 된다. 인코딩된 형식이 아니라 평문 마크다운(F5 export 형식)으로 저장되니, **반드시 비공개 repo** 를 사용한다.
+
+### 일회 설정
+
+```bash
+# 1. 빈 사적 repo 생성 (예: gitea, GitHub private)
+
+# 2. 데이터 디렉터리에 git 초기화 + 원격 등록
+cd "%APPDATA%\Inkling\Inkling\profiles\default\sync"   # Windows
+git init
+git remote add origin https://your-host/owner/inkling-data.git
+git fetch origin || true   # 빈 repo 면 무시
+
+# 3. 자격증명 설정 (Windows Credential Manager 자동 / 또는 token 임베드 URL)
+
+# 4. 첫 동기화: 트레이 → "지금 동기화"
+```
+
+처음 sync 시 SyncService 가 `<profileDir>/sync/` 안에 F5 export 트리(notes/, media/, index.jsonl, manifest.json)를 덮어쓰고 `git add -A && git commit && git push -u origin <branch>` 를 자동 수행.
+
+### 사용
+
+- 트레이 → "지금 동기화" 로 수동 트리거
+- 앱 종료 시 자동 1회 (sync dir 이 설정된 경우만)
+- 변경 없으면 토스트 "변경 사항 없음", 변경 있으면 "동기화 완료"
+
+설정이 안 됐으면 트레이 토스트로 안내. 한 번 설정하면 이후 push 는 OS credential helper 가 자동 처리.
+
+데이터 라이프사이클 측면에서 F6-L1 (로컬 스냅샷, 자동) + F5/F6-L3 (수동 export/import) + F6-L2 (원격 git, 반자동) 3-layer 구조의 마지막 layer.
+```
+
+신규 텍스트 (전체):
+
+```markdown
+## 동기화 (Git, F21 Cut E)
+
+Inkling 데이터를 사적 git 원격으로 양방향 동기화 (Mac ↔ Windows 등). 평문 마크다운(F5 export 형식)으로 저장되니 **반드시 비공개 repo** 를 사용한다.
+
+상세 도움말은 앱 내 설정 → 동기화 저장소 → "도움말" 버튼 (4 섹션 modal) 참조. 본 섹션은 setup + 주요 시나리오 요약.
+
+### 일회 설정
+
+1. 빈 사적 repo 생성 (Gitea / GitHub private)
+2. 앱 → 설정 → 동기화 저장소 → URL 입력 → "저장"
+3. "연결 테스트" 클릭해 인증 / 네트워크 확인
+4. 자동 sync 사용 토글 + interval (기본 30분) 확인
+
+URL 형식 (둘 중 하나):
+
+- SSH: `git@host:user/repo.git`
+- HTTPS: `https://host/user/repo.git`
+
+`git@https://...` 같은 혼합 형식은 거부된다.
+
+### 일상 사용
+
+- 자동 sync: 설정한 interval 마다 + 앱 종료 시 1회
+- 수동 sync: 트레이 → "지금 동기화"
+- 충돌 발생 시 트레이 토스트 + 설정 페이지의 "충돌 해결…" 버튼 → ConflictModal
+
+### 충돌 해결 (ConflictModal)
+
+같은 노트를 두 기기에서 동시에 수정하면 path 별 결정 (내 것 / 원격) 을 받는다.
+
+- **내 것 사용**: 이 기기의 변경을 보존, 원격 변경을 폐기
+- **원격 사용**: 원격 변경을 가져오고, 이 기기의 변경을 폐기
+
+3 케이스:
+
+1. 편집/편집 — 양 텍스트 비교 후 더 새롭고 완전한 쪽 선택. 둘 다 보존하려면 한쪽 선택 + 사후 수동 병합 ('both' 미지원)
+2. 삭제/편집 — 삭제가 의도였으면 원격 사용 (trash 측), 수정이 더 중요하면 내 것 사용 (편집 측 = trash 취소)
+3. AI 결과 충돌 — 한쪽 선택 후 AI 재실행 권장
+
+### Silent risk
+
+- **시계 어긋남 (NTP)**: 양 기기 시계가 다르면 timestamp merge 가 잘못된 결과를 낼 수 있음. NTP 동기화 끄지 말 것
+- **두 기기 동시 수정 회피**: 같은 노트를 동시에 수정하면 conflict 가 잦아짐
+- **자동 sync 실패 silent**: 주기적 sync 실패 시 토스트 안 뜸. 마지막 sync 시각 / 결과는 설정 페이지에서 확인
+
+### Troubleshoot
+
+- **"연결 테스트" 실패** — 네트워크 (브라우저로 호스트 접속) / 인증 (SSH key 또는 token) / URL 오타 점검
+- **인증 실패 (push 안 됨)** — SSH 는 public key 등록 점검, HTTPS 는 OS credential helper (Windows Credential Manager / macOS Keychain) 의 저장 token 점검
+- **URL 변경** — 설정 페이지에서 새 URL 입력 → 저장 (`git remote set-url origin` 자동 처리)
+
+데이터 라이프사이클: F6-L1 (로컬 스냅샷, 자동) + F5/F6-L3 (수동 export/import) + F21 Cut E (양방향 git sync) 3-layer 구조.
+```
+
+Edit tool 호출: `old_string` = 기존 텍스트 전체, `new_string` = 신규 텍스트 전체.
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add README.md
+git commit -m "docs: README 동기화 섹션 Cut E 반영 — 양방향 sync + ConflictModal + Silent risk + Troubleshoot"
+```
+
+---
+
+## Final Verification
+
+- [ ] **Step 1: 전체 단위 + typecheck**
+
+```bash
+cd C:\Users\rlaxo\inkling
+npx tsc --noEmit && npx vitest run
+```
+
+Expected: 0 type errors, 모든 테스트 PASS (직전 base 대비 +11: SyncHelpModal 7 + ConflictModal 회귀 3 + SyncSection 회귀 1)
+
+- [ ] **Step 2: 수동 smoke (electron dev)**
+
+```bash
+npm run dev
+```
+
+확인:
+
+- 설정 → 동기화 저장소 → "도움말" 버튼 클릭 → SyncHelpModal 4 섹션 표시 + ESC/X/overlay close
+- 충돌이 있는 상태에서 "충돌 해결…" → ConflictModal → "자세히 보기" 클릭 → SyncHelpModal 이 메인 conflict 섹션 (#main-conflict) 으로 scroll 된 채 open
+- README 변경 사항을 GitHub/Gitea 웹에서 렌더링 정상 (헤더 / 코드 펜스 / 리스트)
+
+- [ ] **Step 3: 모든 commit history 확인**
+
+```bash
+git log --oneline -6
+```
+
+Expected:
+
+```text
+xxxxxxx docs: README 동기화 섹션 Cut E 반영 — ...
+xxxxxxx feat(sync-help): SyncSection 도움말 버튼 + SyncHelpModal mount + ConflictModal onOpenHelp wiring
+xxxxxxx feat(sync-help): ConflictModal inline 설명 + 자세히 보기 링크 (onOpenHelp prop)
+xxxxxxx feat(sync-help): SyncHelpModal 4 anchor 섹션 (메인 conflict / 자동 / silent / setup)
+xxxxxxx docs(spec): sync 도움말 v0.3.4 — SyncHelpModal + ConflictModal inline + README
+...
+```

docs/superpowers/plans/2026-05-10-v031-cut-f-vision.md

@@ -0,0 +1,841 @@
+# v0.3.1 Cut F — 멀티모달 vision AI Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** F24 — Ollama vision 모델 (gemma3 family default) 활용. 이미지 + raw_text 결합 prompt → title/summary/tags 자동 생성. Capability detection (app launch + manual refresh) + InferenceProvider 확장 + AiWorker 통합 + Configure UI dropdown.
+
+**Architecture:** `isVisionCapable(model)` pure 함수 가 family/families/name 기반으로 vision 가능 모델 판정. `refreshVisionCache(deps)` 가 `/api/tags` 호출 후 settings 에 cache. AiWorker 가 `note.media.length > 0 && visionModel` 둘 다 충족 시 vision path (5MB cap + base64 변환). Configure UI 가 cache 기반 dropdown + manual refresh.
+
+**Tech Stack:** undici/fetch (Ollama API), Node fs/promises (이미지 base64 변환), Electron IPC, React 19 + zustand 5, vitest 4 + RTL.
+
+**선행 문서:**
+
+- `docs/superpowers/specs/2026-05-09-v031-cut-f-design.md` — source spec (Cut F 정정 반영: 단위 679, 실제 SettingsService API, 'skipped' enum 미도입, fallback 미구현)
+- `docs/superpowers/specs/2026-04-25-dogfood-feedback.md` — F24
+- `docs/superpowers/strategy/v028plus-roadmap.md` — Cut F 위치
+
+---
+
+## File Structure
+
+**Create:**
+
+- `src/main/services/VisionDetect.ts` — `isVisionCapable(model)` pure + `refreshVisionCache(deps)` async (Ollama /api/tags)
+- `src/main/ai/visionPrompt.ts` — `buildVisionPrompt(text, todayKst, dueCandidates, vocab)` pure
+- `src/renderer/inbox/components/settings/VisionSection.tsx` — AI 제공자 섹션 안 또는 별도 sub-section. dropdown + 다시 감지 버튼
+- `tests/unit/VisionDetect.test.ts` — isVisionCapable 5 + refreshVisionCache 4
+- `tests/unit/visionPrompt.test.ts` — buildVisionPrompt 2 (text only / image-only fallback)
+- `tests/unit/AiWorker.vision.test.ts` — vision path 3 (text-only / vision body / 5MB cap)
+- `tests/unit/VisionSection.test.tsx` — UI 1 (dropdown + 다시 감지)
+
+**Modify:**
+
+- `src/main/services/SettingsService.ts` — zod schema vision_model / vision_capable_cache / vision_cache_at + 4 메서드
+- `src/main/ai/InferenceProvider.ts` — `GenerateInput.images?: Array<{ base64: string; mime: string }>` + `generate(input, opts?: { visionModel?: string | null })`
+- `src/main/ai/LocalOllamaProvider.ts` — `generate` body 에 `images` 필드 (vision path) + 모델 분기
+- `src/main/ai/AiWorker.ts` — `note.media + visionModel` vision path + 5MB cap + base64 변환. 생성자에 `settings: SettingsService` 의존성 추가
+- `src/main/ipc/settingsApi.ts` — 3 IPC: `settings:get-vision-models` / `settings:set-vision-model` / `settings:refresh-vision-cache`
+- `src/preload/index.ts` — 3 bridge
+- `src/shared/types.ts` — `getSettings()` 반환에 vision_* 3 필드 + InboxApi 3 메서드
+- `src/main/index.ts` — `void refreshVisionCache(...)` whenReady 안 + AiWorker 생성자에 settings 주입
+- `src/renderer/inbox/components/settings/AiProviderSection.tsx` 또는 SettingsPage — VisionSection 마운트
+- `tests/unit/SettingsService.test.ts` — vision 4 메서드 round-trip
+- `tests/unit/LocalOllamaProvider.test.ts` — vision body 분기 회귀
+- `tests/unit/AiWorker.test.ts` — 기존 mock 에 settings stub 추가 (생성자 변경)
+- `package.json` — version 0.3.0 → 0.3.1
+- `docs/superpowers/specs/2026-04-25-dogfood-feedback.md` — F24 promoted
+
+---
+
+## 단위 목표
+
+679 (v0.3.0) → 약 701 (+22), typecheck 0.
+
+---
+
+## Task 1: VisionDetect — `isVisionCapable` + `refreshVisionCache`
+
+**Files:**
+
+- Create: `src/main/services/VisionDetect.ts`
+- Create: `tests/unit/VisionDetect.test.ts`
+
+`isVisionCapable(model)` pure 함수 — family/families/name hints 기반 판정. `refreshVisionCache(deps)` async — `/api/tags` 호출 후 capable 추출 + settings cache 저장. fetch 주입 가능 (테스트).
+
+- [ ] **Step 1: failing test** — `tests/unit/VisionDetect.test.ts`:
+
+```ts
+import { describe, it, expect, vi } from 'vitest';
+import { isVisionCapable, refreshVisionCache } from '../../src/main/services/VisionDetect.js';
+
+describe('isVisionCapable', () => {
+  it('family=gemma3 → true', () => {
+    expect(isVisionCapable({ name: 'gemma3:12b', details: { family: 'gemma3' } })).toBe(true);
+  });
+  it('families=[llava] → true', () => {
+    expect(isVisionCapable({ name: 'llava-13b', details: { families: ['llava'] } })).toBe(true);
+  });
+  it('name hint "vision" → true', () => {
+    expect(isVisionCapable({ name: 'custom-vision-7b' })).toBe(true);
+  });
+  it('text-only family=gemma → false', () => {
+    expect(isVisionCapable({ name: 'gemma4:e4b', details: { family: 'gemma' } })).toBe(false);
+  });
+  it('no hints + unknown family → false', () => {
+    expect(isVisionCapable({ name: 'mistral:7b', details: { family: 'mistral' } })).toBe(false);
+  });
+});
+
+describe('refreshVisionCache', () => {
+  it('happy path — capable 추출 + settings cache 저장', async () => {
+    const settings = {
+      isAiEnabled: vi.fn(async () => true),
+      setVisionCapableCache: vi.fn(async () => {})
+    };
+    const fetchImpl = vi.fn(async () => ({
+      ok: true,
+      status: 200,
+      json: async () => ({
+        models: [
+          { name: 'gemma4:e4b', details: { family: 'gemma' } },
+          { name: 'gemma3:12b-vision', details: { family: 'gemma3' } },
+          { name: 'llava:13b', details: { families: ['llava'] } }
+        ]
+      })
+    })) as unknown as typeof fetch;
+    const r = await refreshVisionCache({
+      settings: settings as never,
+      endpoint: 'http://localhost:11434',
+      fetchImpl
+    });
+    expect(r).toEqual({ ok: true, models: ['gemma3:12b-vision', 'llava:13b'] });
+    expect(settings.setVisionCapableCache).toHaveBeenCalledWith(['gemma3:12b-vision', 'llava:13b'], expect.any(Date));
+  });
+
+  it('ai_disabled → 스킵', async () => {
+    const settings = {
+      isAiEnabled: vi.fn(async () => false),
+      setVisionCapableCache: vi.fn(async () => {})
+    };
+    const r = await refreshVisionCache({ settings: settings as never, endpoint: 'http://x' });
+    expect(r).toEqual({ ok: false, reason: 'ai_disabled' });
+    expect(settings.setVisionCapableCache).not.toHaveBeenCalled();
+  });
+
+  it('http error → ok:false', async () => {
+    const settings = {
+      isAiEnabled: vi.fn(async () => true),
+      setVisionCapableCache: vi.fn(async () => {})
+    };
+    const fetchImpl = vi.fn(async () => ({
+      ok: false,
+      status: 500,
+      json: async () => ({})
+    })) as unknown as typeof fetch;
+    const r = await refreshVisionCache({ settings: settings as never, endpoint: 'http://x', fetchImpl });
+    expect(r).toMatchObject({ ok: false });
+    expect(settings.setVisionCapableCache).not.toHaveBeenCalled();
+  });
+
+  it('unreachable → ok:false', async () => {
+    const settings = {
+      isAiEnabled: vi.fn(async () => true),
+      setVisionCapableCache: vi.fn(async () => {})
+    };
+    const fetchImpl = vi.fn(async () => { throw new Error('ECONNREFUSED'); }) as unknown as typeof fetch;
+    const r = await refreshVisionCache({ settings: settings as never, endpoint: 'http://x', fetchImpl });
+    expect(r).toMatchObject({ ok: false });
+  });
+});
+```
+
+- [ ] **Step 2: implementation** — `src/main/services/VisionDetect.ts`:
+
+```ts
+import type { SettingsService } from './SettingsService.js';
+
+const VISION_FAMILIES = new Set(['gemma3', 'llava', 'llama3.2-vision', 'minicpm-v', 'pixtral']);
+const VISION_NAME_HINTS = ['vision', 'vl', 'multimodal', 'gemma3'];
+
+export interface OllamaModel {
+  name: string;
+  details?: { family?: string; families?: string[] };
+}
+
+export function isVisionCapable(model: OllamaModel): boolean {
+  if (model.details?.family && VISION_FAMILIES.has(model.details.family)) return true;
+  if (model.details?.families?.some((f) => VISION_FAMILIES.has(f))) return true;
+  const lower = model.name.toLowerCase();
+  return VISION_NAME_HINTS.some((h) => lower.includes(h));
+}
+
+export interface RefreshDeps {
+  settings: SettingsService;
+  endpoint: string;
+  now?: () => Date;
+  fetchImpl?: typeof fetch;
+}
+
+export async function refreshVisionCache(
+  deps: RefreshDeps
+): Promise<{ ok: true; models: string[] } | { ok: false; reason: string }> {
+  if (!(await deps.settings.isAiEnabled())) {
+    return { ok: false, reason: 'ai_disabled' };
+  }
+  const fetchFn = deps.fetchImpl ?? fetch;
+  let body: { models?: OllamaModel[] };
+  try {
+    const r = await fetchFn(`${deps.endpoint}/api/tags`);
+    if (!r.ok) return { ok: false, reason: `tags http ${r.status}` };
+    body = (await r.json()) as { models?: OllamaModel[] };
+  } catch (e) {
+    return { ok: false, reason: `unreachable: ${(e as Error).message}` };
+  }
+  const capable = (body.models ?? []).filter(isVisionCapable).map((m) => m.name);
+  const now = deps.now ? deps.now() : new Date();
+  await deps.settings.setVisionCapableCache(capable, now);
+  return { ok: true, models: capable };
+}
+```
+
+- [ ] **Step 3: PASS + commit**
+
+```bash
+npm run typecheck
+npx vitest run tests/unit/VisionDetect.test.ts
+git add src/main/services/VisionDetect.ts tests/unit/VisionDetect.test.ts
+git commit -m "feat(v031): VisionDetect — isVisionCapable + refreshVisionCache (fetch 주입)"
+```
+
+---
+
+## Task 2: SettingsService — vision_model / vision_capable_cache + 4 메서드
+
+**Files:**
+
+- Modify: `src/main/services/SettingsService.ts`
+- Modify: `tests/unit/SettingsService.test.ts`
+
+zod schema 확장 + 4 메서드 추가 (Cut E sync_* 패턴).
+
+- [ ] **Step 1: zod schema 확장** — `src/main/services/SettingsService.ts`:
+
+```ts
+const SettingsSchema = z.object({
+  ollama: OllamaSettingsSchema.optional(),
+  ai_enabled: z.boolean().optional(),
+  onboarding_completed: z.boolean().optional(),
+  sync_repo_url: z.string().nullable().optional(),
+  sync_auto_enabled: z.boolean().optional(),
+  sync_interval_min: z.number().int().min(5).optional(),
+  // v0.3.1 Cut F — vision 모델 (이미지 분석). null/없음 = 비활성.
+  vision_model: z.string().nullable().optional(),
+  vision_capable_cache: z.array(z.string()).optional(),
+  vision_cache_at: z.string().optional()
+}).strict();
+```
+
+- [ ] **Step 2: 4 메서드 추가** (`setSyncIntervalMin` 다음):
+
+```ts
+async getVisionModel(): Promise<string | null> {
+  const s = await this.load();
+  return s.vision_model ?? null;
+}
+
+async setVisionModel(value: string | null): Promise<void> {
+  const current = await this.load();
+  const next: Settings = { ...current, vision_model: value };
+  await this.persist(next);
+}
+
+async getVisionCapableCache(): Promise<{ models: string[]; at: string | null }> {
+  const s = await this.load();
+  return { models: s.vision_capable_cache ?? [], at: s.vision_cache_at ?? null };
+}
+
+async setVisionCapableCache(models: string[], now: Date): Promise<void> {
+  const current = await this.load();
+  const next: Settings = { ...current, vision_capable_cache: models, vision_cache_at: now.toISOString() };
+  await this.persist(next);
+}
+```
+
+- [ ] **Step 3: failing test** — `tests/unit/SettingsService.test.ts` 의 마지막 describe (Cut E sync) 다음에 추가:
+
+```ts
+describe('v0.3.1 Cut F — vision settings', () => {
+  it('getVisionModel() 기본 null', async () => {
+    expect(await svc.getVisionModel()).toBeNull();
+  });
+
+  it('setVisionModel / getVisionModel round-trip + null clear', async () => {
+    await svc.setVisionModel('gemma3:12b-vision');
+    expect(await svc.getVisionModel()).toBe('gemma3:12b-vision');
+    await svc.setVisionModel(null);
+    expect(await svc.getVisionModel()).toBeNull();
+  });
+
+  it('getVisionCapableCache() 기본 빈 배열 + null at', async () => {
+    expect(await svc.getVisionCapableCache()).toEqual({ models: [], at: null });
+  });
+
+  it('setVisionCapableCache 저장 + at ISO', async () => {
+    const at = new Date('2026-05-10T05:00:00Z');
+    await svc.setVisionCapableCache(['gemma3:12b', 'llava:13b'], at);
+    const r = await svc.getVisionCapableCache();
+    expect(r.models).toEqual(['gemma3:12b', 'llava:13b']);
+    expect(r.at).toBe('2026-05-10T05:00:00.000Z');
+  });
+});
+```
+
+- [ ] **Step 4: PASS + commit**
+
+```bash
+npm run typecheck
+npx vitest run tests/unit/SettingsService.test.ts
+git add src/main/services/SettingsService.ts tests/unit/SettingsService.test.ts
+git commit -m "feat(v031): SettingsService.{getVisionModel,setVisionModel,getVisionCapableCache,setVisionCapableCache}"
+```
+
+---
+
+## Task 3: visionPrompt + InferenceProvider 인터페이스 확장
+
+**Files:**
+
+- Create: `src/main/ai/visionPrompt.ts`
+- Modify: `src/main/ai/InferenceProvider.ts`
+- Create: `tests/unit/visionPrompt.test.ts`
+
+`buildVisionPrompt(text, todayKst, dueCandidates, vocab)` pure — 이미지 + raw_text 결합 시나리오. 빈 text 도 처리 ("(이미지만 있음)" placeholder).
+
+- [ ] **Step 1: failing test** — `tests/unit/visionPrompt.test.ts`:
+
+```ts
+import { describe, it, expect } from 'vitest';
+import { buildVisionPrompt } from '../../src/main/ai/visionPrompt.js';
+
+describe('buildVisionPrompt', () => {
+  it('text + 이미지 시 메모 본문 포함', () => {
+    const r = buildVisionPrompt('회의 메모', '2026-05-10', ['2026-05-10'], ['회의']);
+    expect(r).toContain('회의 메모');
+    expect(r).toContain('2026-05-10');
+    expect(r).toContain('회의');
+  });
+
+  it('빈 text → "(이미지만 있음)" placeholder', () => {
+    const r = buildVisionPrompt('', '2026-05-10', [], []);
+    expect(r).toContain('(이미지만 있음)');
+  });
+});
+```
+
+- [ ] **Step 2: implementation** — `src/main/ai/visionPrompt.ts`:
+
+```ts
+/**
+ * v0.3.1 Cut F — 멀티모달 vision prompt. 이미지 + raw_text 결합 분석 후
+ * title/summary/tags/due_date JSON 응답 요청. 빈 raw_text 도 처리.
+ */
+export function buildVisionPrompt(
+  text: string,
+  todayKst: string,
+  dueCandidates: string[],
+  vocab: string[]
+): string {
+  return `다음 메모와 첨부 이미지를 종합 분석해 한국어로 요약하세요.
+
+메모 본문 (비어 있을 수 있음):
+${text || '(이미지만 있음)'}
+
+이미지 분석 시 주요 시각적 정보 (텍스트, 사람, 장면) 도 포함해 요약하세요.
+출력 JSON: { "title": "...", "summary": "...", "tags": [...], "due_date": "..." }
+오늘: ${todayKst}
+가능한 due 후보: ${dueCandidates.join(', ')}
+빈출 태그: ${vocab.slice(0, 20).join(', ')}`;
+}
+```
+
+- [ ] **Step 3: InferenceProvider 인터페이스 확장** — `src/main/ai/InferenceProvider.ts`:
+
+```ts
+export interface GenerateInput {
+  text: string;
+  todayKst: string;
+  dueDateCandidates: string[];
+  vocab?: string[];
+  // v0.3.1 Cut F — 멀티모달 vision (옵션). LocalOllamaProvider 가 visionModel 과 함께 처리.
+  images?: Array<{ base64: string; mime: string }>;
+}
+
+export interface GenerateOptions {
+  visionModel?: string | null;
+}
+
+export interface InferenceProvider {
+  generate(input: GenerateInput, opts?: GenerateOptions): Promise<AiResponse>;
+  // ... 기존 abort / generateRaw
+}
+```
+
+(기존 호출자는 `opts` 미전달이라 호환 — vision path off.)
+
+- [ ] **Step 4: PASS + commit**
+
+```bash
+npm run typecheck
+npx vitest run tests/unit/visionPrompt.test.ts
+git add src/main/ai/visionPrompt.ts src/main/ai/InferenceProvider.ts tests/unit/visionPrompt.test.ts
+git commit -m "feat(v031): buildVisionPrompt + GenerateInput.images + GenerateOptions.visionModel"
+```
+
+---
+
+## Task 4: LocalOllamaProvider — vision path
+
+**Files:**
+
+- Modify: `src/main/ai/LocalOllamaProvider.ts`
+- Modify: `tests/unit/LocalOllamaProvider.test.ts`
+
+`generate(input, opts)` 가 `opts.visionModel + input.images` 둘 다 있으면 vision body 생성 (model = visionModel, prompt = buildVisionPrompt, body.images = base64 array). 그 외는 기존 text-only path.
+
+- [ ] **Step 1: failing test** — 기존 `LocalOllamaProvider.test.ts` 의 적절한 describe 안:
+
+```ts
+describe('vision path (v0.3.1 Cut F)', () => {
+  it('opts.visionModel + input.images 둘 다 있으면 vision body', async () => {
+    let captured: { model?: string; prompt?: string; images?: string[] } = {};
+    const undici = await import('undici');
+    const requestSpy = vi.spyOn(undici, 'request').mockImplementation(async (_url, init) => {
+      captured = JSON.parse(init?.body as string);
+      return {
+        statusCode: 200,
+        body: { json: async () => ({ response: '{"title":"t","summary":"s","tags":[],"due_date":null}' }) }
+      } as never;
+    });
+    const provider = new LocalOllamaProvider({ endpoint: 'http://x', model: 'gemma4:e4b' });
+    await provider.generate(
+      { text: 'hi', todayKst: '2026-05-10', dueDateCandidates: [], images: [{ base64: 'AAAA', mime: 'image/png' }] },
+      { visionModel: 'gemma3:12b-vision' }
+    );
+    expect(captured.model).toBe('gemma3:12b-vision');
+    expect(captured.prompt).toContain('이미지');
+    expect(captured.images).toEqual(['AAAA']);
+    requestSpy.mockRestore();
+  });
+
+  it('visionModel 있어도 images 없으면 text-only path', async () => {
+    let captured: { model?: string; images?: unknown } = {};
+    const undici = await import('undici');
+    const requestSpy = vi.spyOn(undici, 'request').mockImplementation(async (_url, init) => {
+      captured = JSON.parse(init?.body as string);
+      return {
+        statusCode: 200,
+        body: { json: async () => ({ response: '{"title":"t","summary":"s","tags":[],"due_date":null}' }) }
+      } as never;
+    });
+    const provider = new LocalOllamaProvider({ endpoint: 'http://x', model: 'gemma4:e4b' });
+    await provider.generate(
+      { text: 'hi', todayKst: '2026-05-10', dueDateCandidates: [] },
+      { visionModel: 'gemma3:12b-vision' }
+    );
+    expect(captured.model).toBe('gemma4:e4b');
+    expect(captured.images).toBeUndefined();
+    requestSpy.mockRestore();
+  });
+
+  it('opts 미전달 → 기존 text-only (회귀)', async () => {
+    let captured: { model?: string; images?: unknown } = {};
+    const undici = await import('undici');
+    const requestSpy = vi.spyOn(undici, 'request').mockImplementation(async (_url, init) => {
+      captured = JSON.parse(init?.body as string);
+      return {
+        statusCode: 200,
+        body: { json: async () => ({ response: '{"title":"t","summary":"s","tags":[],"due_date":null}' }) }
+      } as never;
+    });
+    const provider = new LocalOllamaProvider({ endpoint: 'http://x', model: 'gemma4:e4b' });
+    await provider.generate({ text: 'hi', todayKst: '2026-05-10', dueDateCandidates: [] });
+    expect(captured.model).toBe('gemma4:e4b');
+    expect(captured.images).toBeUndefined();
+    requestSpy.mockRestore();
+  });
+});
+```
+
+(기존 LocalOllamaProvider.test.ts 의 mock 패턴 따름. test file 의 imports + vi.mock 은 그대로 사용.)
+
+- [ ] **Step 2: implementation** — `LocalOllamaProvider.generate` body 분기:
+
+```ts
+import { buildVisionPrompt } from './visionPrompt.js';
+// ...
+
+async generate(input: GenerateInput, opts?: GenerateOptions): Promise<AiResponse> {
+  const useVision = !!opts?.visionModel && (input.images?.length ?? 0) > 0;
+  const model = useVision ? opts!.visionModel! : this.model;
+  const prompt = useVision
+    ? buildVisionPrompt(input.text, input.todayKst, input.dueDateCandidates, input.vocab ?? [])
+    : buildPrompt(input.text, input.todayKst, input.dueDateCandidates, input.vocab ?? []);
+
+  this.abortController = new AbortController();
+  const timer = setTimeout(() => this.abortController?.abort(), this.timeoutMs);
+  try {
+    const body: Record<string, unknown> = {
+      model,
+      prompt,
+      format: 'json',
+      stream: false,
+      options: { temperature: this.temperature, num_predict: this.numPredict }
+    };
+    if (useVision) {
+      body.images = input.images!.map((i) => i.base64);
+    }
+    const res = await request(`${this.endpoint}/api/generate`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify(body),
+      signal: this.abortController.signal
+    });
+    // ... 기존 parse
+  } finally {
+    // ...
+  }
+}
+```
+
+- [ ] **Step 3: PASS + commit**
+
+```bash
+npm run typecheck
+npx vitest run tests/unit/LocalOllamaProvider.test.ts
+git add src/main/ai/LocalOllamaProvider.ts tests/unit/LocalOllamaProvider.test.ts
+git commit -m "feat(v031): LocalOllamaProvider vision path (visionModel + images → body.images base64)"
+```
+
+---
+
+## Task 5: AiWorker — vision integration + 5MB cap + settings 의존성
+
+**Files:**
+
+- Modify: `src/main/ai/AiWorker.ts`
+- Modify: `tests/unit/AiWorker.test.ts`
+- Create: `tests/unit/AiWorker.vision.test.ts`
+
+AiWorker 가 `note.media + visionModel` 조건에서 base64 변환 (5MB cap) + provider.generate 에 images + visionModel 전달. 생성자에 `settings: SettingsService` 의존성 추가.
+
+- [ ] **Step 1: AiWorker 생성자 변경** — settings 파라미터 추가. `src/main/index.ts` 의 인스턴스 생성도 갱신.
+
+- [ ] **Step 2: AiWorker.processJob 갱신**:
+
+```ts
+import { readFile } from 'node:fs/promises';
+// 클래스 안 generate 호출 직전:
+const visionModel = await this.settings.getVisionModel();
+let images: Array<{ base64: string; mime: string }> | undefined;
+if (visionModel && note.media.length > 0) {
+  images = await Promise.all(
+    note.media.map(async (m) => {
+      const buf = await readFile(this.mediaStore.absolutePath(m.relPath));
+      if (buf.byteLength > 5 * 1024 * 1024) {
+        throw new Error(`image ${m.relPath} exceeds 5MB cap`);
+      }
+      return { base64: buf.toString('base64'), mime: m.mime };
+    })
+  );
+}
+const res = await this.holder.get().generate(
+  { text: note.rawText, images, todayKst: todayIso, dueDateCandidates: candidates, vocab },
+  { visionModel: visionModel ?? undefined }
+);
+```
+
+`mediaStore: MediaStore` 도 AiWorker 생성자에 신규 파라미터 (현재 없으면 추가; main 에서 주입).
+
+- [ ] **Step 3: failing test** — `tests/unit/AiWorker.vision.test.ts`:
+
+```ts
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { writeFile, mkdtemp, mkdir, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import Database from 'better-sqlite3';
+import { runMigrations } from '../../src/main/db/migrations/index.js';
+import { NoteRepository } from '../../src/main/repository/NoteRepository.js';
+import { AiWorker } from '../../src/main/ai/AiWorker.js';
+import { MediaStore } from '../../src/main/services/MediaStore.js';
+
+describe('AiWorker — vision path (v0.3.1 Cut F)', () => {
+  let db: Database.Database;
+  let repo: NoteRepository;
+  let workDir: string;
+  let mediaStore: MediaStore;
+
+  beforeEach(async () => {
+    db = new Database(':memory:');
+    db.pragma('foreign_keys = ON');
+    runMigrations(db);
+    repo = new NoteRepository(db);
+    workDir = await mkdtemp(join(tmpdir(), 'inkling-vision-'));
+    mediaStore = new MediaStore(workDir);
+  });
+
+  afterEach(async () => {
+    db.close();
+    await rm(workDir, { recursive: true, force: true });
+  });
+
+  it('visionModel + media 있음 → provider.generate 가 images + opts 받음', async () => {
+    const { id } = repo.create({ rawText: '이미지 메모' });
+    const mediaPath = join(workDir, 'media', id, '1.png');
+    await mkdir(join(workDir, 'media', id), { recursive: true });
+    await writeFile(mediaPath, Buffer.from([0x89, 0x50, 0x4e, 0x47]));  // 4 bytes PNG-ish
+    repo.insertMedia([{ noteId: id, kind: 'image', relPath: `media/${id}/1.png`, mime: 'image/png', bytes: 4 }]);
+
+    const generate = vi.fn(async () => ({ title: 't', summary: 's', tags: [], dueDate: null }));
+    const provider = { name: 'fake', generate, abort: () => {} };
+    const settings = {
+      getVisionModel: vi.fn(async () => 'gemma3:12b-vision'),
+      isAiEnabled: vi.fn(async () => true)
+    } as unknown as never;
+    const worker = new AiWorker(/* ...deps with settings + mediaStore + repo + holder = { get: () => provider } */);
+    await worker['processJob']({ noteId: id, attempts: 0, nextRunAt: '' });
+
+    expect(generate).toHaveBeenCalledWith(
+      expect.objectContaining({ images: expect.any(Array) }),
+      expect.objectContaining({ visionModel: 'gemma3:12b-vision' })
+    );
+    const callArg = generate.mock.calls[0]![0] as { images: Array<{ base64: string; mime: string }> };
+    expect(callArg.images).toHaveLength(1);
+    expect(callArg.images[0]!.mime).toBe('image/png');
+  });
+
+  it('visionModel 없으면 text-only (회귀)', async () => {
+    const { id } = repo.create({ rawText: 'just text' });
+    const generate = vi.fn(async () => ({ title: 't', summary: 's', tags: [], dueDate: null }));
+    const provider = { name: 'fake', generate, abort: () => {} };
+    const settings = {
+      getVisionModel: vi.fn(async () => null),
+      isAiEnabled: vi.fn(async () => true)
+    } as unknown as never;
+    const worker = new AiWorker(/* ... */);
+    await worker['processJob']({ noteId: id, attempts: 0, nextRunAt: '' });
+    expect(generate).toHaveBeenCalledWith(
+      expect.not.objectContaining({ images: expect.anything() }),
+      expect.any(Object)
+    );
+  });
+
+  it('5MB 초과 이미지 → throw → ai_status=failed', async () => {
+    const { id } = repo.create({ rawText: 'big image' });
+    const mediaPath = join(workDir, 'media', id, '1.png');
+    await mkdir(join(workDir, 'media', id), { recursive: true });
+    await writeFile(mediaPath, Buffer.alloc(6 * 1024 * 1024));  // 6 MB
+    repo.insertMedia([{ noteId: id, kind: 'image', relPath: `media/${id}/1.png`, mime: 'image/png', bytes: 6 * 1024 * 1024 }]);
+
+    const generate = vi.fn(async () => ({ title: 't', summary: 's', tags: [], dueDate: null }));
+    const settings = {
+      getVisionModel: vi.fn(async () => 'gemma3:12b-vision'),
+      isAiEnabled: vi.fn(async () => true)
+    } as unknown as never;
+    const worker = new AiWorker(/* ... */);
+    await worker['processJob']({ noteId: id, attempts: 0, nextRunAt: '' });
+    // 5MB cap 초과 throw → AiWorker 의 attempts 증가 분기 → ai_status='failed'
+    const note = repo.findById(id);
+    expect(['failed', 'pending']).toContain(note!.aiStatus);  // attempts 모두 소진 시 'failed'; 첫 시도 throw 시 'pending' 유지 가능 — 구현 의존
+  });
+});
+```
+
+(NOTE: 정확한 AiWorker 생성자 인자 — 기존 test 의 setup 패턴 따라 deps 전체 stub 구성. 위 코드는 outline; 실수행자가 기존 `AiWorker.test.ts` setup 참고하여 정확한 deps 구조 채움.)
+
+- [ ] **Step 4: 기존 AiWorker.test.ts mock 갱신** — 생성자에 `settings` / `mediaStore` 파라미터 추가됨. 모든 기존 test 의 worker 생성 site 에 stub 추가.
+
+- [ ] **Step 5: PASS + commit**
+
+```bash
+npm run typecheck
+npx vitest run tests/unit/AiWorker.test.ts tests/unit/AiWorker.vision.test.ts
+git add src/main/ai/AiWorker.ts \
+        src/main/index.ts \
+        tests/unit/AiWorker.test.ts \
+        tests/unit/AiWorker.vision.test.ts
+git commit -m "feat(v031): AiWorker vision integration — note.media + visionModel + 5MB cap"
+```
+
+---
+
+## Task 6: types + IPC + preload
+
+**Files:**
+
+- Modify: `src/shared/types.ts` — `getSettings()` 반환에 vision_model / vision_capable_cache / vision_cache_at + InboxApi 3 메서드
+- Modify: `src/main/ipc/settingsApi.ts` — 3 IPC handler
+- Modify: `src/preload/index.ts` — 3 bridge
+- Create: `tests/unit/vision-ipc.test.ts`
+
+3 채널:
+- `settings:get-vision-models` → `{ models: string[]; at: string | null; selected: string | null }` (cache 결과 + 현재 선택)
+- `settings:set-vision-model` (value: string | null) → `{ ok: true }`
+- `settings:refresh-vision-cache` → `{ ok: true; models: string[] } | { ok: false; reason: string }` (refreshVisionCache 호출)
+
+상세 패턴은 Cut E sync IPC 와 동일.
+
+- [ ] **Step 1: types** + **Step 2: failing test** + **Step 3: handlers** + **Step 4: preload bridges** — Cut E sync-ipc 패턴 그대로
+
+- [ ] **Step 5: PASS + commit**
+
+```bash
+git add src/shared/types.ts src/main/ipc/settingsApi.ts src/preload/index.ts tests/unit/vision-ipc.test.ts
+git commit -m "feat(v031): vision IPC + preload (get-vision-models / set / refresh)"
+```
+
+---
+
+## Task 7: VisionSection UI + AI 제공자 섹션 통합
+
+**Files:**
+
+- Create: `src/renderer/inbox/components/settings/VisionSection.tsx`
+- Modify: `src/renderer/inbox/components/settings/AiProviderSection.tsx` 또는 SettingsPage — 마운트
+- Create: `tests/unit/VisionSection.test.tsx`
+
+dropdown (cache 기반) + 다시 감지 버튼 + 마지막 감지 시각 표시. dropdown 변경 시 `setVisionModel` 호출. 다시 감지 → `refreshVisionCache` IPC + dropdown 갱신.
+
+```tsx
+// 핵심 구조 (Cut E SyncSection 패턴)
+const [models, setModels] = useState<string[]>([]);
+const [at, setAt] = useState<string | null>(null);
+const [selected, setSelected] = useState<string | null>(null);
+const [busy, setBusy] = useState<'select' | 'refresh' | null>(null);
+
+useEffect(() => {
+  void (async () => {
+    const r = await inboxApi.getVisionModels();
+    setModels(r.models);
+    setAt(r.at);
+    setSelected(r.selected);
+  })();
+}, []);
+
+async function onSelect(value: string) {
+  setBusy('select');
+  await inboxApi.setVisionModel(value === '' ? null : value);
+  setSelected(value === '' ? null : value);
+  setBusy(null);
+}
+
+async function onRefresh() {
+  setBusy('refresh');
+  const r = await inboxApi.refreshVisionCache();
+  setBusy(null);
+  if (r.ok) {
+    const cache = await inboxApi.getVisionModels();
+    setModels(cache.models);
+    setAt(cache.at);
+  }
+}
+```
+
+UI:
+
+```tsx
+<select value={selected ?? ''} onChange={(e) => void onSelect(e.target.value)} aria-label="이미지 분석 모델">
+  <option value="">(비활성)</option>
+  {models.map((m) => <option key={m} value={m}>{m}</option>)}
+</select>
+<button onClick={() => void onRefresh()} disabled={busy === 'refresh'}>
+  {busy === 'refresh' ? '감지 중…' : '다시 감지'}
+</button>
+{at !== null && <span>마지막 감지: {new Date(at).toLocaleString('ko-KR')}</span>}
+```
+
+- [ ] **Step 1-5: 컴포넌트 + test + 마운트 + commit**
+
+```bash
+git add src/renderer/inbox/components/settings/VisionSection.tsx \
+        src/renderer/inbox/components/settings/AiProviderSection.tsx \
+        tests/unit/VisionSection.test.tsx
+git commit -m "feat(v031): VisionSection — dropdown + 다시 감지 + 마지막 감지 시각"
+```
+
+---
+
+## Task 8: main process — refreshVisionCache 자동 호출 + AiWorker settings 주입
+
+**Files:**
+
+- Modify: `src/main/index.ts`
+
+`whenReady` 안 (Ollama provider 준비 후) `void refreshVisionCache(...)` fire-and-forget 호출. AiWorker 생성자에 settings + mediaStore 주입.
+
+- [ ] **Step 1: imports + 호출** — `src/main/index.ts`:
+
+```ts
+import { refreshVisionCache } from './services/VisionDetect.js';
+
+// whenReady 안, AiWorker.start() 직후 또는 직전
+const ollama = providerHolder.get();
+void refreshVisionCache({
+  settings: settingsSvc,
+  endpoint: (ollama as LocalOllamaProvider).endpoint,  // 또는 SettingsService 의 ollama 설정에서 가져옴
+}).catch(() => {});
+```
+
+(LocalOllamaProvider 의 endpoint 가 private 이면 settings 에서 가져옴 또는 provider 에 getter 추가.)
+
+- [ ] **Step 2: AiWorker 생성자 인자 갱신**
+
+- [ ] **Step 3: typecheck + PASS + commit**
+
+```bash
+npm run typecheck
+npx vitest run
+git add src/main/index.ts
+git commit -m "feat(v031): main — refreshVisionCache whenReady + AiWorker settings/mediaStore 주입"
+```
+
+---
+
+## Task 9: dogfood promoted + version bump + release commit
+
+- [ ] F24 promoted 마킹 (`docs/superpowers/specs/2026-04-25-dogfood-feedback.md`):
+
+```markdown
+## F24. 멀티모달 vision (✅ promoted v0.3.1 Cut F)
+
+**상태:** ✅ promoted v0.3.1 Cut F — Ollama vision 모델 (gemma3 family default) 활용. capability detection (app launch + manual refresh) + Configure UI dropdown + AiWorker vision integration (5MB cap + base64 변환). 자동 fallback (caption → text) deferred v0.3.2+.
+```
+
+- [ ] package.json: 0.3.0 → 0.3.1 + package-lock.json
+- [ ] full unit + typecheck
+
+```bash
+git add docs/superpowers/specs/2026-04-25-dogfood-feedback.md package.json package-lock.json
+git commit -m "chore(release): v0.3.1 — Cut F (멀티모달 vision AI)"
+```
+
+---
+
+## Self-Review Checklist (수행자: 모든 task 완료 후 1회 점검)
+
+- [ ] **Spec coverage**: §3 Capability Detection (Task 1) / §3-2 SettingsService (Task 2) / §3-3 main wiring (Task 8) / §3-4 UI (Task 7) / §4 Provider (Tasks 3-4) / §5 AiWorker (Task 5) / §6 image-only fallback ('skipped' enum 미도입 → 기존 'failed' 분기 활용)
+- [ ] **Single write path 강제 (Cut C/D/E 정책)**: 본 cut 은 새 데이터 path 추가 없음 — `notes_fts` / `note_revisions` / `note_tags` mutation 없음 (vision 결과는 기존 `updateAiResult` path 활용 → 이미 검증됨). 회귀 검사 4-path invariant 유지.
+- [ ] **Type 일관성**: `GenerateInput.images` ↔ `GenerateOptions.visionModel` ↔ AiWorker 호출 ↔ LocalOllamaProvider body 모두 동일 shape
+- [ ] **단위 카운트**: VisionDetect 9 (5+4) + SettingsService 4 + visionPrompt 2 + LocalOllamaProvider 3 + AiWorker 3 + IPC 3-5 + UI 1 = 약 25-27 신규. 목표 22 달성
+
+---
+
+## Risk
+
+- **vision 모델 한국어 정확도**: gemma3 family 가 한국어 약하면 다른 family 추천 갱신 (메모리 정책). dogfood 검증 필요
+- **Ollama 가 vision images 무시 (모델 misclassify)**: capability detection false-positive — 사용자가 dropdown 에서 다른 모델 선택해 우회. 자동 fallback 미구현 (YAGNI)
+- **base64 메모리 폭주**: 5MB cap 적용. 다중 이미지 시 N×5MB = 메모리 누적 — vision 호출 후 image array 즉시 GC. 본 cut 의 dogfood 규모 (메모당 < 3 이미지) 무시
+- **capability detection 실패 silent**: 첫 launch 시 network 실패 → cache 빈 채로 진행. 사용자가 설정 페이지에서 "다시 감지" 클릭 → 직접 trigger 가능
+- **AiWorker 생성자 변경**: 기존 test 모두 mock 갱신 필요 (typecheck 가 catch). 누락 시 typecheck red
+- **F23 OFF (ai_enabled=false) 시 자동 OFF**: refreshVisionCache 가 ai_enabled 체크 → ai_disabled 분기. AiWorker 의 vision path 진입 자체가 ai_enabled=true 가정 — F23 OFF 시 vision path 미도달 (자명)
+- **e2e**: Cut C/D/E 와 동일 — 본 cut 미수행, main 머지 후 검증

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

@@ -1423,9 +1423,9 @@ app.on('activate', () => {
 
 ---
 
-## F19. 획기적 recall 메커니즘 (🌱 raw — v0.2.8+ 큰 영역, 본질 재설계 가능)
+## F19. 획기적 recall 메커니즘 (✅ promoted v0.2.11 Cut D — A+D 옵션)
 
-**진행 상태:** 🌱 raw — 핵심 가치 영역. v0.2.8 brainstorm 시 별도 spec 후보 (recall 만 단독 cut 가치).
+**진행 상태:** ✅ promoted v0.2.11 Cut D — A (FTS5 search) + D (일/주/월 회고 view) 적용. m007 마이그레이션 + `NoteRepository.search` + `reviewAggregate` + SearchBox + ReviewView. B/C/E/F 옵션은 v0.3+ deferred.
 
 **발견:** 2026-05-09 v0.2.7 release 후 본인 dogfood. "메모의 빠른 기록도 중요하지만 적절한 recall 도 훨씬 중요" — 본인 표현.
 
@@ -1570,9 +1570,9 @@ app.on('activate', () => {
 
 ---
 
-## F21. 다기기 git-based 동기화 (🌱 raw — v0.2.8 후보, **부분 구현됨**)
+## F21. 다기기 git-based 동기화 (✅ promoted v0.3.0 Cut E — 양방향 + Configure UI + Conflict)
 
-**진행 상태:** 🌱 raw — `SyncService` + `GitClient` 가 이미 push-only 형태로 존재. **양방향 동기화 + UI 구성** 이 누락된 핵심 부분. v0.2.8 brainstorm 시 명확한 cut.
+**진행 상태:** ✅ promoted v0.3.0 Cut E — 옵션 A (자동 rebase) + B (Configure UI) + C (conflict UI). SyncService 양방향 6단계 (export → commit → fetch → rebase → re-import → push), `NoteRepository.upsertFromSync` (sync 전용 3 분기), `SettingsService.{getSyncRepoUrl,isAutoSyncEnabled,getSyncIntervalMin}` + `SyncTimer` (자동 주기 + reconfigure), `SyncSection` UI + `ConflictModal` (local/remote 2 choice, both deferred v0.3.1+). 단위 608 → 679. dogfood 1주 soak 후 Cut F (F24 vision) 진입.
 
 **발견:** 2026-05-09 v0.2.7 release 후 본인 dogfood. 사용자 표현: "그 중심에 git repo 를 쓸 수 있으면 좋겠어".
 
@@ -1787,9 +1787,9 @@ app.on('activate', () => {
 
 ---
 
-## F24. 이미지 멀티모달 AI 분석 (🌱 raw — v0.2.8/v0.3 후보, capability gated)
+## F24. 이미지 멀티모달 AI 분석 (✅ promoted v0.3.1 Cut F)
 
-**진행 상태:** 🌱 raw — Ollama vision 모델 (llava / llama3.2-vision / gemma3-multimodal 등) 활용. 사용자 표현: "가능할 경우만 하면 될 것 같다" — capability detection + opt-in 명시.
+**진행 상태:** ✅ promoted v0.3.1 Cut F — Ollama vision 모델 (gemma3 family default) 활용. capability detection (app launch + manual refresh) + Configure UI dropdown + AiWorker vision integration (5MB cap + base64 변환). 자동 fallback (caption → text) + 'skipped' enum deferred v0.3.2+. 단위 679 → 710. dogfood: vision 결과 정확도 + 한국어 token 정확도 검증.
 
 **발견:** 2026-05-09 v0.2.7 release 후 본인 dogfood. F22 (이미지 렌더링) + F23 (Ollama-less 모드) 와 강하게 연관.
 

docs/superpowers/specs/2026-05-09-v0211-cut-d-design.md

@@ -27,35 +27,52 @@ recall 핵심 가치 도달 — search + 회고 view. F19 의 6 옵션 중 **A (
 
 ## 3. F19-A 디테일 (FTS5)
 
-### 3-1. Schema 마이그레이션 (m006)
+### 3-1. Schema 마이그레이션 (m007)
+
+> 메모: 본 스펙 작성 시점에는 m006 로 예상했으나 Cut C (v0.2.10) 에서 m006 (note_revisions) 가 선점됨 → 실제 번호는 **m007**.
+
+실제 schema 정정:
+- `notes.title`/`notes.summary` 컬럼 없음 → 실제 `notes.ai_title`/`notes.ai_summary` 사용
+- `notes.tags_csv` 컬럼 없음 → tags 는 `note_tags` join (note_tags.note_id ↔ tags.id)
+- `notes.status` (Cut B m004 도입) 사용 가능 — `status != 'trashed'` 필터
 
 ```sql
 CREATE VIRTUAL TABLE notes_fts USING fts5(
   note_id UNINDEXED,
   raw_text,
-  title,
-  summary,
+  ai_title,
+  ai_summary,
   tags,
   tokenize='unicode61'
 );
 
--- 기존 notes 모두 인덱스
-INSERT INTO notes_fts (note_id, raw_text, title, summary, tags)
-  SELECT id, raw_text, title, summary, tags_csv FROM notes WHERE status != 'trashed';
+-- 기존 notes (active/completed/archived 만 — trashed 제외) 모두 인덱스.
+-- tags 는 note_tags+tags JOIN 후 GROUP_CONCAT 으로 csv 구성.
+INSERT INTO notes_fts (note_id, raw_text, ai_title, ai_summary, tags)
+  SELECT
+    n.id,
+    n.raw_text,
+    COALESCE(n.ai_title, ''),
+    COALESCE(n.ai_summary, ''),
+    COALESCE((SELECT GROUP_CONCAT(t.name, ' ')
+                FROM note_tags nt JOIN tags t ON t.id = nt.tag_id
+               WHERE nt.note_id = n.id), '')
+  FROM notes n
+  WHERE n.status != 'trashed';
 ```
 
 `tokenize='unicode61'` — 한국어 partial tokenize 가능 (단어 boundary). 향후 `tokenize='porter unicode61'` 또는 한국어 전용 tokenizer (예: `mecab-ko-fts5`) 검토 가능 — Cut D 는 unicode61 default.
 
-`tags_csv` — notes.tags (JSON array) 를 csv 로 flatten 하여 인덱스 (예: `"기획 회의 결재"`).
+`tags` 컬럼 = note_tags JOIN 결과 csv (예: `"기획 회의 결재"`). `note_tags` 변경 시 NoteRepository 에서 명시적 헬퍼 (`rebuildFtsTagsForNote(noteId)`) 호출 — trigger 로 sync 어려움 (`note_tags` INSERT/DELETE 가 다른 노트 row 재계산 트리거하기 부담). 단일 write path 패턴 (Cut C 확립) 으로 강제.
 
-### 3-2. Trigger — auto-sync
+### 3-2. Trigger — auto-sync (notes 컬럼 한정)
 
-`notes` INSERT/UPDATE/DELETE 시 `notes_fts` 자동 sync:
+`notes` INSERT/UPDATE/DELETE 시 `notes_fts` 자동 sync (raw_text/ai_title/ai_summary 만; tags 는 별도 헬퍼):
 
 ```sql
 CREATE TRIGGER notes_ai AFTER INSERT ON notes BEGIN
-  INSERT INTO notes_fts (note_id, raw_text, title, summary, tags)
-    VALUES (NEW.id, NEW.raw_text, NEW.title, NEW.summary, NEW.tags_csv);
+  INSERT INTO notes_fts (note_id, raw_text, ai_title, ai_summary, tags)
+    VALUES (NEW.id, NEW.raw_text, COALESCE(NEW.ai_title, ''), COALESCE(NEW.ai_summary, ''), '');
 END;
 
 CREATE TRIGGER notes_ad AFTER DELETE ON notes BEGIN
@@ -63,32 +80,45 @@ CREATE TRIGGER notes_ad AFTER DELETE ON notes BEGIN
 END;
 
 CREATE TRIGGER notes_au AFTER UPDATE ON notes BEGIN
-  UPDATE notes_fts SET raw_text=NEW.raw_text, title=NEW.title, summary=NEW.summary, tags=NEW.tags_csv
-    WHERE note_id = NEW.id;
+  UPDATE notes_fts
+     SET raw_text   = NEW.raw_text,
+         ai_title   = COALESCE(NEW.ai_title, ''),
+         ai_summary = COALESCE(NEW.ai_summary, '')
+   WHERE note_id = NEW.id;
 END;
 ```
 
 Cut C 의 `updateRawText` 가 `notes.raw_text` UPDATE → trigger 자동 발동 → FTS5 갱신.
 
-`tags_csv` 는 별도 generated column 또는 NoteRepository 에서 수동 갱신 (zod parse 후 csv join). YAGNI: 수동 갱신.
+`tags` 갱신 path:
+- `NoteRepository.updateAiResult` (AI tags) / `updateUserAiFields` (사용자 tags) 모두 `note_tags` 변경 후 동일 transaction 안에서 `rebuildFtsTagsForNote(noteId)` 호출.
+
+trashed 노트 처리 — `setStatus(id, 'trashed', ...)` 시 trigger AFTER UPDATE 발동되어 FTS row 가 그대로 유지됨. 검색 시 query 단계에서 `n.status != 'trashed'` 필터로 제외 (별도 FTS row cleanup 안 함 — YAGNI).
 
 ### 3-3. NoteRepository.search
 
 ```ts
-search(query: string, opts: { limit?: number; status?: NoteStatus }): Note[] {
-  const limit = opts.limit ?? 50;
-  const statusClause = opts.status ? `AND n.status = ?` : '';
+search(query: string, opts: { limit?: number; status?: NoteStatus } = {}): Note[] {
+  if (query.trim().length === 0) return [];
+  const limit = Math.max(1, Math.min(200, opts.limit ?? 50));
+  const ftsQuery = sanitizeFtsQuery(query);  // FTS5 special char escape
+  const statusClause = opts.status ? `AND n.status = ?` : `AND n.status != 'trashed'`;
   const sql = `
     SELECT n.* FROM notes n
     JOIN notes_fts f ON n.id = f.note_id
     WHERE notes_fts MATCH ? ${statusClause}
     ORDER BY rank LIMIT ?
   `;
-  const args = opts.status ? [query, opts.status, limit] : [query, limit];
-  return this.db.prepare(sql).all(...args) as Note[];
+  const args = opts.status ? [ftsQuery, opts.status, limit] : [ftsQuery, limit];
+  const rows = this.db.prepare(sql).all(...args) as Record<string, unknown>[];
+  return rows.map((r) => this.hydrate(r));
 }
 ```
 
+`hydrate` — 기존 패턴 (tags + media join). `sanitizeFtsQuery` — FTS5 special chars (`"`, `*`, `(`, `)`, `:`) 이스케이프 및 multi-word AND 결합 (예: `기획 회의` → `"기획" AND "회의"` 또는 `기획 회의` 그대로 수용). YAGNI: 다중 토큰을 그대로 FTS5 implicit AND 로 보냄 + 따옴표 제거.
+
+`status` 미지정 시 default = trashed 제외.
+
 `MATCH` 쿼리 syntax — FTS5 standard (`"기획 회의"`, `회의 OR 결재`, `기획*` 등).
 
 ### 3-4. UI — inbox 헤더 search box
@@ -149,23 +179,55 @@ export function ReviewView({ period }: { period: 'daily' | 'weekly' | 'monthly'
 NoteRepository:
 
 ```ts
-reviewAggregate(period: 'daily' | 'weekly' | 'monthly', now: Date): {
+reviewAggregate(period: 'daily' | 'weekly' | 'monthly', now: Date = new Date()): {
   totalCount: number;
   recentNotes: Note[];
   tagCounts: Array<{ tag: string; count: number }>;
   dueProgress: { total: number; passed: number; pending: number };
 } {
-  const cutoff = computeCutoff(period, now);
-  // 단일 transaction 안에 N개 query
-  const totalCount = this.db.prepare(`SELECT COUNT(*) as c FROM notes WHERE created_at >= ? AND status != 'trashed'`).get(cutoff).c;
-  const recentNotes = this.db.prepare(`SELECT * FROM notes WHERE created_at >= ? AND status != 'trashed' ORDER BY created_at DESC LIMIT 50`).all(cutoff);
-  // tagCounts — JSON tags array unnest → group by
-  // dueProgress — due_date 컬럼 + KST 비교
-  return { ... };
+  const cutoff = computeCutoff(period, now);  // ISO string — KST 자정 / 7일전 / 30일전
+  const todayIso = kstTodayIso(now);  // YYYY-MM-DD
+  const totalCount = (this.db
+    .prepare(`SELECT COUNT(*) as c FROM notes WHERE created_at >= ? AND status != 'trashed'`)
+    .get(cutoff) as { c: number }).c;
+  const recentRows = this.db
+    .prepare(`SELECT * FROM notes WHERE created_at >= ? AND status != 'trashed'
+              ORDER BY created_at DESC, id DESC LIMIT 50`)
+    .all(cutoff) as Record<string, unknown>[];
+  const recentNotes = recentRows.map((r) => this.hydrate(r));
+  // tag counts via note_tags JOIN — period 안 노트의 태그만 집계
+  const tagCounts = this.db
+    .prepare(`SELECT t.name AS tag, COUNT(*) AS count
+              FROM note_tags nt
+              JOIN notes n ON n.id = nt.note_id
+              JOIN tags t ON t.id = nt.tag_id
+              WHERE n.created_at >= ? AND n.status != 'trashed'
+              GROUP BY t.id
+              ORDER BY count DESC, t.name ASC`)
+    .all(cutoff) as Array<{ tag: string; count: number }>;
+  // due progress — period 안 created 노트 중 due_date 가 있는 것
+  const dueRow = this.db
+    .prepare(`SELECT
+                COUNT(*) AS total,
+                SUM(CASE WHEN due_date < ? THEN 1 ELSE 0 END) AS passed,
+                SUM(CASE WHEN due_date >= ? THEN 1 ELSE 0 END) AS pending
+              FROM notes
+              WHERE created_at >= ?
+                AND status != 'trashed'
+                AND due_date IS NOT NULL`)
+    .get(todayIso, todayIso, cutoff) as { total: number; passed: number | null; pending: number | null };
+  const dueProgress = {
+    total: dueRow.total,
+    passed: dueRow.passed ?? 0,
+    pending: dueRow.pending ?? 0
+  };
+  return { totalCount, recentNotes, tagCounts, dueProgress };
 }
 ```
 
-`computeCutoff('daily', now)` = KST 자정. `'weekly'` = 7일 전 KST. `'monthly'` = 30일 전 KST.
+`computeCutoff('daily', now)` = KST 자정 (오늘 시작) ISO. `'weekly'` = 7일 전 KST 자정 ISO. `'monthly'` = 30일 전 KST 자정 ISO. `kstTodayIso` 는 `src/shared/util/kstDate.ts` 에 이미 존재 (Cut B 활용).
+
+period 별 query 는 동일 transaction 으로 wrap 해도 되나, read-only + 단일 호출이라 단순 sequential 호출로 충분 (better-sqlite3 동기 API).
 
 ### 4-4. Tag distribution chart
 
@@ -195,14 +257,19 @@ reviewAggregate(period: 'daily' | 'weekly' | 'monthly', now: Date): {
 
 | 영역 | 단위 |
 |---|---|
-| m006 마이그레이션 | FTS5 virtual table 생성 + 기존 notes backfill (status != 'trashed' 만) |
-| Trigger sync | INSERT/UPDATE/DELETE → notes_fts 자동 sync |
-| `search` | 한국어 token 매칭 + status filter |
+| m007 마이그레이션 | FTS5 virtual table + trigger 3개 + 기존 notes backfill (status != 'trashed' + tags JOIN) |
+| Trigger sync | INSERT/UPDATE/DELETE → notes_fts 자동 sync (raw_text/ai_title/ai_summary) |
+| `rebuildFtsTagsForNote` 헬퍼 | note_tags 변경 후 FTS tags 컬럼 재구성 |
+| `updateAiResult` / `updateUserAiFields` | tags 변경 path 가 헬퍼 호출하여 FTS sync (회귀) |
+| `updateRawText` (Cut C) FTS sync 회귀 | trigger 자동 발동 검증 |
+| `search` | 한국어 token 매칭 + status filter + trashed 기본 제외 + 빈 query → [] |
+| `sanitizeFtsQuery` | FTS5 special char 이스케이프 + multi-word 통과 |
 | inbox header search box | debounce + 빈 값 → 기본 list 복귀 |
-| ReviewView 단위 | aggregate query 결과 렌더 |
-| `reviewAggregate` | period 별 cutoff 정확 + tag count + due progress |
+| ReviewView 단위 | aggregate query 결과 렌더 + period 라벨 |
+| `reviewAggregate` | period 별 cutoff 정확 + tag count + due progress (passed/pending KST 비교) |
+| `computeCutoff` | daily/weekly/monthly KST 자정 ISO |
 
-**목표**: 단위 505 → 약 528 (+23), typecheck 0.
+**목표**: 단위 569 → 약 595 (+26), typecheck 0.
 
 ---
 
@@ -213,7 +280,9 @@ reviewAggregate(period: 'daily' | 'weekly' | 'monthly', now: Date): {
 | FTS5 한국어 token 정확도 (unicode61 가 word boundary 부정확) | dogfood 검증. 부족 시 v0.3+ 에서 mecab-ko 또는 trigram tokenize 검토 |
 | FTS5 인덱스 size (notes 수만건 시 DB 크기 ↑) | 수만건 도달 전엔 무시. v0.3+ 에서 prune 또는 partial 인덱스 |
 | 회고 aggregate query latency | LIMIT 50 + index 활용 (`created_at DESC`). 수만건도 sub-second 예상 |
-| Cut C revision 추가 시 FTS 영향 | revision 은 인덱스 X (latest only). 정책 일관 |
+| Cut C revision 추가 시 FTS 영향 | revision 은 인덱스 X (latest only). `notes` AFTER UPDATE trigger 가 raw_text 변경 자동 반영 |
+| `note_tags` 변경 누락 시 FTS tags stale | NoteRepository 의 tags 변경 path 모두에서 `rebuildFtsTagsForNote` 명시 호출 — single write path 패턴 강제 |
+| FTS5 special char crash | `sanitizeFtsQuery` 에서 `"`/`*`/`(`/`)`/`:` 이스케이프 또는 제거 |
 
 ---
 

docs/superpowers/specs/2026-05-09-v030-cut-e-design.md

@@ -38,60 +38,81 @@ async sync(opts: { interval?: boolean } = {}): Promise<SyncStatus> {
 
   const git = new GitClient(this.syncDir);
 
-  // 1. fetch
-  const fetchR = await git.fetch();
-  if (fetchR.exitCode !== 0) return { ok: false, reason: `fetch failed: ${fetchR.stderr}` };
-
-  // 2. local export (변경 감지 위해)
+  // 1. local export — 현재 SQLite 상태를 syncDir 에 markdown 으로 출력
   await this.exportSvc.export(this.syncDir, { includeMedia: true });
   await git.addAll();
   const localChanged = await git.hasUncommittedChanges();
 
-  // 3. local commit (있으면)
+  // 2. local commit (변경 있으면)
   let localSha: string | null = null;
   if (localChanged) {
     const c = await git.commit(`chore(notes): sync ${this.now().toISOString()}`);
     localSha = c.sha;
   }
 
-  // 4. rebase
+  // 3. fetch
+  const fetchR = await git.fetch();
+  if (fetchR.exitCode !== 0) return { ok: false, reason: `fetch failed: ${fetchR.stderr}` };
+
+  // 4. rebase onto origin/main
   const rebaseR = await git.rebaseOnto('origin/main');
   if (rebaseR.exitCode !== 0) {
-    // conflict — abort + 사용자에게 conflict UI 안내
+    // conflict — abort + conflict 목록 반환 (UI 가 활성)
     await git.rebaseAbort();
-    return { ok: false, reason: 'conflict', conflicts: await this.listConflicts() };
+    return { ok: false, reason: 'conflict', conflicts: await this.listConflictsFromMarkdown() };
   }
 
-  // 5. re-import (rebase 후 markdown 변경 → SQLite 적용)
-  const imported = await this.importSvc.importAll(this.syncDir);
+  // 5. re-import (rebase 후 markdown 변경 → SQLite upsertFromSync)
+  const imported = await this.importSvc.applySyncFromDir(this.syncDir);
 
   // 6. push
-  const pushR = await git.push();
-  if (pushR.exitCode !== 0) return { ok: false, reason: `push failed: ${pushR.stderr}` };
+  try { await git.push(); } catch (e) { return { ok: false, reason: `push failed: ${(e as Error).message}` }; }
 
   return { ok: true, changed: localChanged || imported.changedCount > 0, localSha, importedCount: imported.changedCount, pushed: true };
 }
 ```
 
-### 3-2. ImportService 활용
+**6 단계 흐름 — local export 가 fetch 보다 먼저 (Cut E 정정)**: spec 초안은 fetch 우선이었으나, local export → commit 후 fetch + rebase 가 git workflow 표준 (rebase 가 local commit 위에 origin commit 적용). local export 안 한 상태로 fetch + rebase → 혼란 발생.
 
-기존 ImportService (백업 복원 흐름) 가 markdown → SQLite 적재. sync 의 re-import 도 같은 service 활용:
+`SyncStatus` 인터페이스 확장:
 
 ```ts
-class ImportService {
-  async importAll(dir: string): Promise<{ changedCount: number; conflicts: string[] }> {
-    // dir 하위의 모든 .md 파일 → frontmatter parse → notes UPSERT
-    // existing note 와 비교 — updated_at 더 최신이면 갱신, 아니면 skip
-    // raw_text 다른 경우 → note_revisions 에 INSERT (new rev, edited_by='sync')
-  }
+export interface SyncStatus {
+  ok: boolean;
+  reason?: string;
+  changed?: boolean;
+  localSha?: string | null;
+  pushed?: boolean;
+  importedCount?: number;
+  conflicts?: Array<{ noteId: string; localText: string; remoteText: string }>;  // reason='conflict' 시
 }
 ```
 
-**revision linear merge 정책**:
+### 3-2. ImportService 활용 (실제 코드 정정)
 
-- 옛 rev (origin/main 의 rev_5) 가 local 에 없으면 → INSERT note_revisions (timestamp 기준 적절 위치)
-- local rev 와 origin rev 가 동일 timestamp + 다른 raw_text → conflict (사용자 prompt)
-- 일반적으로 다른 timestamp 면 timestamp 순 linear chain 으로 merge
+기존 ImportService 는 `run(sourceDir)` 메서드 (백업 복원 흐름) — `parsedToInput` → `repo.importNote()` 호출. spec 작성 시 가정한 `importAll(dir)` 시그니처는 실재 코드와 다름.
+
+`repo.importNote()` 의 기존 conflict 정책 (export tree 복원용):
+
+- id 없음 → INSERT (`status: 'inserted'`)
+- id 있음 + raw_text 동일 → no-op (`status: 'skipped'`)
+- id 있음 + raw_text 다름 → fork-on-id-collision (fresh uuidv7) (`status: 'forked'`)
+
+**Cut E sync 정책 — fork 미적합, in-place update + revision 보존**:
+
+sync 에서 양 기기 raw_text 가 다를 때 fork 하면 노트 갯수 무한 증가 → 부적합. 신설 메서드 `repo.upsertFromSync(input)`:
+
+- id 없음 → INSERT (m006 trigger 가 capture revision 자동 생성)
+- id 있음 + raw_text 동일 → metadata 갱신 path
+  - source.updatedAt > local.updatedAt 인 경우만 ai_title/ai_summary/tags/status/dueDate 갱신
+  - tags 변경 시 `rebuildFtsTagsForNote` 호출 (Cut D single write path)
+  - 동등/older 면 skip
+- id 있음 + raw_text 다름 → 옵션 분기:
+  - source.updatedAt > local.updatedAt → `updateRawText(id, sourceRawText, sourceUpdatedAt)` (Cut C single write path) → 새 user revision INSERT, latest = source
+  - local.updatedAt > source.updatedAt → skip (다음 push 가 source 갱신할 것)
+  - 동일 timestamp + 다른 raw_text → SyncService 가 conflict 마킹 (rebase 단계 git markdown conflict 가 먼저 잡힘 — 본 분기는 rare)
+
+**revision edited_by**: 'sync' enum 추가 안 함 — `updateRawText` 의 default 'user' 그대로 활용 (sync = user-edited 변경 전파 = 의미상 user). YAGNI: m008 회피.
 
 ### 3-3. GitClient 확장
 
@@ -193,7 +214,7 @@ settings: `sync_auto_enabled: boolean` (default true 단, configured 일 때만)
 | Conflict UI | 3 choice 별 sync 동작 |
 | 자동 주기 sync | timer + interval=true mode |
 
-**목표**: 단위 528 → 약 555 (+27), typecheck 0.
+**목표**: 단위 608 → 약 635 (+27), typecheck 0.
 
 ---
 

docs/superpowers/specs/2026-05-09-v031-cut-f-design.md

@@ -12,7 +12,7 @@
 
 ## 1. Cut 정체성
 
-Ollama vision 모델 (gemma3 family default) 활용 — 이미지 + raw_text 결합 prompt 또는 이미지 단독 분석 → title/summary/tags 자동 생성. F22 prerequisite (Cut A) 이미 완료.
+Ollama vision 모델 (gemma family — gemma3 / gemma4 default capable) 활용 — 이미지 + raw_text 결합 prompt 또는 이미지 단독 분석 → title/summary/tags 자동 생성. F22 prerequisite (Cut A) 이미 완료.
 
 ---
 
@@ -20,7 +20,7 @@ Ollama vision 모델 (gemma3 family default) 활용 — 이미지 + raw_text 결
 
 | 항목 | 결정 |
 |---|---|
-| **F24 default 모델** | gemma3 family (한국어 + 이미지 둘 다 강함, 본인 메모 `gemma4:e4b` 텍스트 모델과 같은 가족) |
+| **F24 default 모델** | gemma family — gemma3 / gemma4 둘 다 vision-capable hint (한국어 + 이미지 둘 다 강함, 본인 메모 `gemma4:e4b` 텍스트 모델과 같은 가족) |
 | **prompt 모드** | 단일 vision 모델 호출 (vision 모델이 텍스트도 처리). 모델 capability 부족 시 2단계 fallback (자동) |
 | **capability detection** | app launch 시 1회 + 설정 페이지 manual refresh 버튼 |
 | **F23 OFF 시 자동 OFF** | `ai_enabled=false` → vision 도 자동 OFF (자명) |
@@ -56,36 +56,59 @@ function isVisionCapable(model: { name: string; details?: { family?: string; fam
 }
 ```
 
-### 3-2. Settings storage
+### 3-2. Settings storage (실제 SettingsService API)
+
+zod schema 확장 (기존 ai_enabled / sync_* 와 동일 strict 패턴):
 
 ```ts
-interface SettingsSchema {
-  // ... 기존
-  vision_model?: string;       // 사용자 명시 모델 (빈 값 = 비활성)
-  vision_capable_cache?: string[];  // launch 시 detected 결과 cache
-  vision_cache_at?: string;    // ISO timestamp
-}
+const SettingsSchema = z.object({
+  // ... 기존 ollama / ai_enabled / onboarding_completed / sync_*
+  vision_model: z.string().nullable().optional(),
+  vision_capable_cache: z.array(z.string()).optional(),
+  vision_cache_at: z.string().optional()
+}).strict();
+```
+
+신규 SettingsService 메서드 (개별 setter/getter — `get/set` 일반화 X):
+
+```ts
+async getVisionModel(): Promise<string | null>;
+async setVisionModel(value: string | null): Promise<void>;
+async getVisionCapableCache(): Promise<{ models: string[]; at: string | null }>;
+async setVisionCapableCache(models: string[], now: Date): Promise<void>;
 ```
 
 ### 3-3. AppLaunchDetect
 
-```ts
-// src/main/index.ts whenReady 안 (settings 초기화 후)
-async function refreshVisionCache(): Promise<void> {
-  if (!settingsService.get('ai_enabled', true)) return;
-  try {
-    const tags = await fetch(`${endpoint}/api/tags`).then(r => r.json());
-    const capable = tags.models.filter(isVisionCapable).map((m: any) => m.name);
-    settingsService.set('vision_capable_cache', capable);
-    settingsService.set('vision_cache_at', new Date().toISOString());
-  } catch {
-    // network fail — silent, cache 유지
-  }
-}
+`src/main/services/VisionDetect.ts` 신규 — pure 함수 + 외부 fetch 주입 (테스트 가능):
 
-void refreshVisionCache();
+```ts
+export async function refreshVisionCache(deps: {
+  settings: SettingsService;
+  endpoint: string;
+  now?: () => Date;
+  fetchImpl?: typeof fetch;
+}): Promise<{ ok: true; models: string[] } | { ok: false; reason: string }> {
+  if (!(await deps.settings.isAiEnabled())) {
+    return { ok: false, reason: 'ai_disabled' };
+  }
+  const fetchFn = deps.fetchImpl ?? fetch;
+  let body: { models?: Array<{ name: string; details?: { family?: string; families?: string[] } }> };
+  try {
+    const r = await fetchFn(`${deps.endpoint}/api/tags`);
+    if (!r.ok) return { ok: false, reason: `tags http ${r.status}` };
+    body = await r.json();
+  } catch (e) {
+    return { ok: false, reason: `unreachable: ${(e as Error).message}` };
+  }
+  const capable = (body.models ?? []).filter(isVisionCapable).map((m) => m.name);
+  await deps.settings.setVisionCapableCache(capable, deps.now ? deps.now() : new Date());
+  return { ok: true, models: capable };
+}
 ```
 
+main process `whenReady` 안에서 fire-and-forget 호출. 실패 silent (cache 유지). settings:refresh-vision-cache IPC 가 동일 함수 호출 (manual "다시 감지" 버튼).
+
 ### 3-4. 설정 페이지 UI (AI 제공자 섹션 확장)
 
 ```
@@ -166,44 +189,53 @@ ${text || '(이미지만 있음)'}
 
 ---
 
-## 5. AiWorker 통합
+## 5. AiWorker 통합 (실제 API 정정)
 
-CaptureService 가 capture 시 image 첨부했으면 → notes.media 에 저장 + pending_jobs INSERT. AiWorker 가 job 처리 시:
+기존 `AiWorker.processJob` 이 `repo.findById(noteId)` 로 hydrate 된 `Note` 받음 — `note.media` 가 이미 join 결과로 채워져 있어 별도 `listMediaByNote` 호출 불필요. `MediaStore.absolutePath(relPath)` 로 디스크 path 추출.
 
 ```ts
-// src/main/ai/AiWorker.ts
-async processJob(noteId: string): Promise<void> {
-  const note = this.repo.getById(noteId);
-  const media = this.repo.listMediaByNote(noteId);
-  const visionModel = this.settings.get('vision_model');
+// src/main/ai/AiWorker.ts processJob 흐름
+const note = this.repo.findById(job.noteId);
+if (!note || ...) return;
+const visionModel = await this.settings.getVisionModel();
 
-  let images: Array<{ base64: string; mime: string }> | undefined;
-  if (visionModel && media.length > 0) {
-    images = await Promise.all(media.map(async (m) => ({
-      base64: (await fs.readFile(this.mediaStore.absolutePath(m.relPath))).toString('base64'),
-      mime: m.mime
-    })));
-  }
-
-  const provider = this.providerHolder.get();
-  const response = await provider.generate({ text: note.rawText, images, ... }, { visionModel });
-  // ... 기존 결과 적용
+let images: Array<{ base64: string; mime: string }> | undefined;
+if (visionModel && note.media.length > 0) {
+  images = await Promise.all(
+    note.media.map(async (m) => {
+      const buf = await readFile(this.mediaStore.absolutePath(m.relPath));
+      // 이미지당 5MB cap (base64 메모리 폭주 방지)
+      if (buf.byteLength > 5 * 1024 * 1024) {
+        throw new Error(`image ${m.relPath} exceeds 5MB cap`);
+      }
+      return { base64: buf.toString('base64'), mime: m.mime };
+    })
+  );
 }
+
+const res = await this.holder.get().generate({
+  text: note.rawText,
+  images,
+  todayKst,
+  dueDateCandidates: candidates,
+  vocab
+}, { visionModel });
 ```
 
-`media.length > 0 && visionModel` 둘 다 true 일 때만 vision path. 그 외는 기존 text-only.
+`visionModel && note.media.length > 0` 둘 다 true 일 때만 vision path. 그 외는 기존 text-only path 유지 (호환 보존). image 5MB cap 초과 시 throw → 기존 AiWorker 의 attempts 카운트 + ai_status='failed' 분기 활용.
+
+AiWorker 의 `settings: SettingsService` 의존성 추가 — 기존 생성자에 신규 파라미터.
 
 ---
 
-## 6. 이미지만 있는 capture
+## 6. 이미지만 있는 capture (정정 — 신규 enum 도입 X)
 
-`raw_text` 빈 값 + media 첨부만:
+`raw_text` 빈 값 + media 첨부만 케이스:
 
-- 기존 동작: notes INSERT (raw_text=''), AiWorker 가 빈 prompt 로 호출 → ai_status='failed' 또는 무의미 응답
-- vision enabled: AiWorker 가 vision prompt + images → 의미 있는 title/summary/tags 응답
-- vision disabled (visionModel 빈 값): notes 저장만, ai_status='disabled' 신규 enum 활용 (Cut B 의 ai_enabled false 와 비슷한 의미 — 그러나 부분 disable, 즉 "이미지 only 라 처리 불가" 상태)
+- **vision enabled** (`visionModel` 설정 + media 있음): AiWorker 의 vision path → 의미 있는 title/summary/tags 응답
+- **vision disabled** (`visionModel` null): 기존 text-only 흐름 그대로 — 빈 prompt → AI 응답이 무의미하면 ai_status='failed' 분기 (재시도 가능). dogfood 시 빈도 측정 후 'skipped' enum 도입 여부 재평가.
 
-추천: vision disabled + image-only capture 시 `ai_status='skipped'` 신규 enum (Cut B 의 'disabled' 와 다름). title fallback = "(이미지 N개)" 또는 첫 이미지 파일명.
+**'skipped' 신규 enum 미도입 (YAGNI)**: m008 마이그레이션 (CHECK relax via table recreate) 부담 + 이미지-only capture 가 본 cut 의 main use case 가 아님. 사용자가 vision 활성 후 retry 하거나 raw_text 추가 후 reprocess 하는 우회로 충분. 정책 검토는 dogfood 후 별도 cut.
 
 ---
 
@@ -219,7 +251,7 @@ async processJob(noteId: string): Promise<void> {
 | `AiWorker.processJob` vision integration | media + visionModel 있을 때만 base64 변환 |
 | 이미지 only capture | raw_text='' + media → vision 결과 정상 또는 'skipped' 분기 |
 
-**목표**: 단위 555 → 약 575 (+20), typecheck 0.
+**목표**: 단위 679 → 약 701 (+22, isVisionCapable 5 + refreshVisionCache 4 + SettingsService vision 4 + LocalOllamaProvider vision path 3 + buildVisionPrompt 2 + AiWorker vision integration 3 + UI dropdown 1), typecheck 0.
 
 ---
 
@@ -231,7 +263,7 @@ async processJob(noteId: string): Promise<void> {
 | 이미지 base64 메모리 부담 | media 1개당 평균 < 1MB. 다중 이미지 시 N×base64 = 메모리 N배. cap (이미지당 max size 5MB) 적용 |
 | capability detection 실패 시 fallback | cache 부재 → vision dropdown 비어있음 표시 + "다시 감지" 안내 |
 | vision 모델 한국어 정확도 | dogfood 검증. gemma3 가 한국어 약하면 다른 family 추천 갱신 (메모리 정책 갱신) |
-| Ollama 가 vision images 필드 무시 (모델이 multimodal 미지원) | 자동 2단계 fallback — vision 모델로 caption 추출 → 텍스트 모델로 종합 (capability 부족 시) |
+| Ollama 가 vision images 필드 무시 (모델이 multimodal 미지원) | **본 cut 미구현 (YAGNI)** — 자동 2단계 fallback (caption 추출 → 텍스트 모델 종합) 은 v0.3.2+ 검토. dogfood 시 capability detection 정확도 우선 |
 
 ---
 

docs/superpowers/specs/2026-05-09-v032-cut-g-design.md

@@ -1,5 +1,7 @@
 # v0.3.2 — Cut G Design (사이드바 + notebook 카테고리)
 
+> **[Deprecated 2026-05-14]** 본 cut 은 [v0.4 design](2026-05-14-v04-notebooks-lifecycle-design.md) 으로 승격되며 lifecycle 단순화 (archived 제거) 를 함께 다룸. dogfood 데이터 (archived 0건 / 19일) 가 archived 차원의 dead code 임을 입증해 묶음 변경이 정신 부담 측면에서 더 정합. 본 문서는 history 참조용으로 유지.
+
 **작성일:** 2026-05-09
 **선행 문서:**
 

docs/superpowers/specs/2026-05-10-sync-help-design.md

@@ -0,0 +1,138 @@
+# Sync 도움말 — Design
+
+날짜: 2026-05-10
+대상 버전: v0.3.4 (또는 v0.4.0 통합 시 Cut G 안에 포함)
+선행 의존: v0.3.0 Cut E (양방향 sync), v0.3.3 (configure-sync ENOENT hotfix)
+
+## 배경
+
+v0.3.0 Cut E 가 양방향 sync (configure UI + ConflictModal + auto-sync timer) 를 도입했지만, 사용자에게 노출되는 도움말은 다음 세 곳 모두 부족 또는 부재:
+
+- **SettingsPage > 동기화 저장소**: URL 입력 + 저장/연결 테스트 + 자동 sync 토글만 있음. 무엇이 어떻게 동작하는지 안내 0.
+- **ConflictModal**: "내 것 사용 (local)" / "원격 사용 (remote)" 버튼만 노출, 각 옵션의 의미·결과 미설명. 사용자는 추측에 의존.
+- **README "원격 백업 (F6-L2)" 섹션**: v0.2.1 MVP 시점 기준 (트레이 "지금 동기화" + 수동 `git init`). Cut E 의 Configure UI / ConflictModal / auto-sync timer 미반영 — 사용자가 따라하면 어긋남.
+
+다기기 (Mac + Windows) sync dogfood 는 본인 + 사내 베타 10인의 핵심 가치 검증인데, conflict 시나리오에 막혔을 때 도움말이 없어 사용자가 직접 git 내부 동작을 추측해야 하는 상태.
+
+## 목표
+
+git 기반 sync 의 정상 동작·이상 시나리오·복구 절차를 사용자가 막힌 순간에 바로 찾을 수 있게 만든다.
+
+비목표:
+
+- 'both' choice (v0.3.1+ deferred) 도움말
+- 다국어 (앱 한국어 only)
+- 스크린샷·GIF (텍스트만으로 충분)
+- README 외 docs/sync-guide.md 별도 파일 (in-app 이 메인, README 가 보조 — 별도 파일 발견성 ↓)
+
+## 표면 (3개)
+
+### 1. SyncHelpModal — 신규 컴포넌트
+
+**위치**: `src/renderer/inbox/components/SyncHelpModal.tsx`
+
+**진입점**:
+
+- `SyncSection.tsx`: URL 입력 row 옆에 "도움말" 버튼 추가 → 클릭 시 modal open
+- `ConflictModal.tsx`: 각 옵션 설명 옆 "자세히 보기 →" 링크 → SyncHelpModal open + "메인 conflict" 섹션으로 스크롤
+
+**구조**: `ConflictModal` 패턴 재사용 (overlay + 닫기 버튼 + scrollable body). 4 섹션 (단순 anchor jump — 좌측 nav 미도입, modal 무게 ↓):
+
+1. **메인 conflict** — 편집/편집, 삭제/편집, AI 결과 충돌 3 케이스 + 각 결정 트리
+2. **자동 처리** — fetch+rebase, 첫 sync 순서, push 순서 ("내가 안 해도 되는 일")
+3. **Silent risk** — 시계 어긋남(NTP), 결합 실패 silent, dogfood 주의
+4. **Setup/인증** — URL 형식 (SSH vs HTTPS), 인증 helper, 연결 실패 troubleshoot
+
+**Close**: ESC + 우상단 X + overlay 클릭 (ConflictModal 패턴 일치).
+
+### 2. ConflictModal 갱신
+
+**현재**: 각 conflict path 에 대해 "내 것 사용 (local)" / "원격 사용 (remote)" 버튼만.
+
+**변경**: 각 옵션 라벨 아래 1-2 줄 inline 설명 + "자세히 보기 →" 링크.
+
+```text
+내 것 사용 (local)
+  이 기기의 변경을 보존하고 원격의 같은 노트 변경을 폐기.
+  자세히 보기 →
+
+원격 사용 (remote)
+  원격 (다른 기기 또는 백업) 의 변경을 가져오고 내 변경을 폐기.
+  자세히 보기 →
+```
+
+"자세히 보기" 클릭 → SyncHelpModal open (메인 conflict 섹션 anchor).
+
+### 3. README "원격 백업 (F6-L2)" 섹션 통째 재작성
+
+**현재 (line 193-223)**: v0.2.1 MVP 기준 stale.
+
+**신규 헤더**: "## 동기화 (Git, F21 Cut E)"
+
+**하위 절**:
+
+- 일회 설정 — Settings > 동기화 저장소 UI 안내 (트레이 "지금 동기화" 안내 제거 — 현재 UI 와 다름)
+  - URL 형식 명확화: `git@host:user/repo.git` (SSH) 또는 `https://host/owner/repo.git` (HTTPS). v0.3.3 dogfood 에서 발견된 `git@https://` 혼합 오류 사례 명시
+- 일상 사용 — auto-sync 주기 / 수동 트리거 / 충돌 시 ConflictModal 안내
+- 충돌 해결 — local/remote 결정 트리 (in-app SyncHelpModal 과 같은 내용)
+- Silent risk — 시계 어긋남, 동시 수정 회피
+- Troubleshoot — push 실패 / 인증 실패 / 첫 sync 순서
+
+## 콘텐츠 분배
+
+| 시나리오 | SyncHelpModal | ConflictModal inline | README |
+|---|---|---|---|
+| 편집/편집 conflict | 결정 트리 (어떤 변경이 더 최신인지 / 둘 다 보존하려면 사후 수동 병합) | 1줄 + "자세히" 링크 | 상세 + 예시 |
+| 삭제/편집 | 케이스 설명 (삭제 측이 'remote' 면 trash 로 이동, 편집 측이 'local' 이면 trash 취소) | (해당 없음 — path 가 같음) | 케이스 설명 |
+| AI 결과 충돌 | "재처리 권장" — local/remote 한쪽 선택 후 AI 재실행 권장 | (해당 없음) | 케이스 설명 |
+| fetch+rebase 자동 | "내가 안 해도 되는 일" 단원 | — | 동일 |
+| 첫 sync 순서 | "Mac 먼저 push → Windows pull 후 push" | — | 동일 |
+| 시계 어긋남 (NTP) | "두 기기 동시 수정 회피", `chrony` / Windows time sync 점검 안내 | — | 동일 |
+| Setup/URL 형식 | SSH/HTTPS 예시, `git@https://` 같은 혼합 형식 거부 사례 | — | 동일 + 인증 helper 안내 |
+| 인증 실패 | "OS credential helper 점검", token URL embed 우회 옵션 | — | 동일 |
+
+## 변경 파일
+
+**신규**:
+
+- `src/renderer/inbox/components/SyncHelpModal.tsx`
+- `tests/unit/SyncHelpModal.test.tsx`
+
+**수정**:
+
+- `src/renderer/inbox/components/settings/SyncSection.tsx` — "도움말" 버튼 추가 (URL row 옆)
+- `src/renderer/inbox/components/ConflictModal.tsx` — 각 옵션 inline 설명 + "자세히" 링크
+- `tests/unit/ConflictModal.test.tsx` — inline 설명 / 링크 클릭 시 SyncHelpModal open 회귀
+- `tests/unit/SyncSection.test.tsx` — 도움말 버튼 클릭 → SyncHelpModal open 회귀
+- `README.md` — "원격 백업 (F6-L2)" 섹션 line 193-223 통째 재작성
+
+## 게이트
+
+- `SyncHelpModal.test.tsx` 신규 — 4 섹션 렌더링, close (ESC/X/overlay), anchor jump
+- `ConflictModal.test.tsx` 회귀 — inline 설명 표시, "자세히" 링크 → SyncHelpModal open
+- `SyncSection.test.tsx` 회귀 — 도움말 버튼 → SyncHelpModal open
+- typecheck 0
+- 단위 +6~8 (SyncHelpModal 4 + ConflictModal 회귀 1 + SyncSection 회귀 1)
+- e2e 미수행 (UI-only, 기존 capture/onboarding flow 무관)
+
+## Risk
+
+- **콘텐츠 정확성**: AI 결과 충돌 / 시계 어긋남 같은 시나리오는 dogfood 미경험 (v0.3.3 까지 1 dogfood 발견). 도움말이 실제 사용자 경험과 어긋날 risk → 1주 dogfood soak 후 도움말 텍스트 1차 갱신 필수
+- **README 와 in-app 의 중복 maintain**: 두 곳에 같은 내용. 정합성 깨질 risk → 우선순위는 in-app (사용자가 보는 위치). README 는 보조
+- **'both' choice 부재 안내**: v0.3.1+ deferred 인데 사용자가 "왜 둘 다 보존이 없냐" 질문 가능 → 도움말에 "현재 미지원, 사후 수동 병합" 명시
+- **콘텐츠 길이**: SyncHelpModal 4 섹션이 길어지면 modal 자체가 무거워짐 → 각 섹션 200 자 이내 + README 가 상세. modal 은 "막힌 순간 결정 트리" 우선
+
+## 비포함 / Deferred
+
+- 'both' choice 도움말 (Cut E 정책 deferred)
+- 다국어 (앱 한국어 only)
+- 스크린샷 / GIF
+- 별도 docs/sync-guide.md (README + in-app 으로 충분)
+- ConflictModal 의 diff 시각 개선 (별개 task, 본 도움말 cut 의 scope 외)
+- 도움말 검색 기능 (4 섹션, 짧음)
+
+## How to apply
+
+- v0.3.4 patch 또는 Cut G 안에 통합. 단독 cut 으로 갈 경우 v0.3.4 — 데이터/마이그레이션 변경 0
+- dogfood 1주 soak 후 도움말 텍스트 정합성 1차 갱신 (실제 사용자 경험과 어긋난 부분 보강)
+- ConflictModal 의 inline 설명은 "자세히 보기" 링크 한 번이 SyncHelpModal 메인 conflict 섹션 anchor 로 점프 — anchor id 명명: `#main-conflict`, `#auto`, `#silent`, `#setup`

docs/superpowers/specs/2026-05-10-v032-cleanup-design.md

@@ -0,0 +1,320 @@
+# v0.3.2 — Cleanup Cut Design
+
+**작성일:** 2026-05-10
+**선행 문서:**
+
+- `docs/superpowers/v024-backlog.md` (잔여 backlog audit)
+- `~/.claude/projects/c--Users-rlaxo-inkling/memory/project_v022_feedback.md` (stale memory — 본 cut 에서 폐기)
+- `docs/superpowers/strategy/v028plus-roadmap.md`
+
+**Cut 라벨:** v0.3.2 — patch (기능 추가 X, 잠재 bug fix + cosmetic + 기록 정리)
+
+---
+
+## 1. Cut 정체성
+
+기능 추가 X. backlog 잔여 23건 중 **잠재 bug 4건 + cosmetic 6건 + 기록 정리 2건 = 12건** 일괄 처리. data-dependent 항목 (telemetry 분포 의존) 과 cross-cutting refactor (TrayController class / Banner CSS variables) 는 dogfood 후 재평가. Cut F (v0.3.1) + Cut E (v0.3.0) 종합 dogfood ≥1주 soak 진입을 위한 baseline 정리.
+
+---
+
+## 2. 범위
+
+| 항목 | 결정 |
+|---|---|
+| **포함 카테고리** | 잠재 bug + cosmetic + 기록 정리 |
+| **보류 카테고리** | data-dependent (9건) + cross-cutting refactor (4건) |
+| **테스트 +** | 단위 710 → 약 720 (+10), typecheck 0 |
+| **schema 변경** | 없음 (m007 이후) |
+| **단일 PR** | v0.3.2 — 12 항목 = 7~8 commit (카테고리별 묶음) |
+
+---
+
+## 3. 잠재 bug fix (4건)
+
+### 3-1. `vocabSet` COLLATE NOCASE 정합 (#31)
+
+**현재 코드** (`src/main/ai/AiWorker.ts` `processJob`):
+
+```ts
+const vocab = await this.repo.getTopUsedTags(VOCAB_TOP_N);
+const vocabSet = new Set(vocab);
+// ...
+if (vocabSet.has(tagName)) { ... }  // strict-eq, DB COLLATE NOCASE 와 충돌 가능
+```
+
+**문제**: vocab pool 확장 시 (사용자가 `'Design'` 같은 capital case 추가하면) `getTagIdByName('Design')` 은 COLLATE NOCASE 로 매치되지만 `vocabSet.has('Design')` strict-eq 는 lowercase 만 등록된 set 에 miss → tagId 있는데 vocab hit 0 → silently skip.
+
+**수정**:
+
+```ts
+const vocab = await this.repo.getTopUsedTags(VOCAB_TOP_N);
+const vocabSet = new Set(vocab.map((v) => v.toLowerCase()));
+// ...
+if (vocabSet.has(tagName.toLowerCase())) { ... }
+```
+
+**테스트 (3건 신규)**:
+
+- 대문자 vocab + lowercase AI tag → hit
+- lowercase vocab + 대문자 AI tag → hit
+- 동일 lowercase → hit (회귀)
+
+### 3-2. Time-dependent test flake fix
+
+**문제**: `NoteRevisions.test.ts` 의 v1 capture 가 `repo.create()` 호출 → `NoteRepository.create` 가 `new Date()` (NOW) 로 `created_at` / `edited_at` 박음. v2 는 fixed `2026-05-10T00:00:00Z` 명시 주입. 시스템 시계가 `2026-05-10T00:00:00Z` 초과 시 v1.edited_at > v2.edited_at → DESC ordering 깨짐. `upsertFromSync.test.ts` 도 동일 패턴.
+
+**수정**: `NoteRepository.create(input, now?: Date)` 추가 (기존 `setStatus(id, status, reason, now: Date)` / `updateRawText(id, text, now: Date)` 패턴 정합).
+
+```ts
+// src/main/repository/NoteRepository.ts
+create(input: CreateNoteInput, now: Date = new Date()): Note {
+  const ts = now.toISOString();
+  // 기존 INSERT 의 createdAt / updatedAt / edited_at 모두 ts 사용
+  // ...
+}
+```
+
+**기존 호출자 무영향** — production 코드는 `now` 생략 → 기본 `new Date()` 동일 동작.
+
+**테스트 (5건 회복 + 2건 신규)**:
+
+- `NoteRevisions.test.ts` 의 4 testcase v1 capture 도 fixed 시간 (`'2026-05-09T00:00:00Z'`) 주입 → v2 (`'2026-05-10T00:00:00Z'`) 이전 보장
+- `upsertFromSync.test.ts` 의 v1 capture 도 fixed 시간 주입
+- `NoteRepository.create` default 시간 (`now` 생략 시 `new Date()`) 단위 1
+- `NoteRepository.create` 명시 주입 단위 1
+
+### 3-3. PII reason 마스킹 (#39)
+
+**현재 코드** (`src/main/ai/LocalOllamaProvider.ts` `healthCheck`):
+
+```ts
+} catch (e) {
+  this.telemetry?.emit({ kind: 'ollama_unreachable', payload: { reason: `unreachable: ${(e as Error).message}` } });
+}
+```
+
+**문제**: `err.message` 안에 `http://192.168.x.x:11434/api/tags` 같은 LAN endpoint URL 포함 가능 → telemetry 파일에 PII 우회 노출. v0.2.3.1 in-app endpoint UI 가 LAN 사용 흔하게 만들어 노출 경로 확대.
+
+**수정**: error class 분류 + host 마스킹.
+
+```ts
+function classifyFetchError(e: unknown): 'timeout' | 'network' | 'dns' | 'other' {
+  const msg = (e as Error).message?.toLowerCase() ?? '';
+  if (msg.includes('aborted') || msg.includes('timeout')) return 'timeout';
+  if (msg.includes('econnrefused') || msg.includes('econnreset')) return 'network';
+  if (msg.includes('enotfound') || msg.includes('eai_again')) return 'dns';
+  return 'other';
+}
+
+// emit
+const reason = classifyFetchError(e);
+this.telemetry?.emit({ kind: 'ollama_unreachable', payload: { reason } });
+```
+
+`AiFailedReason` zod enum (`'unreachable' | 'schema' | 'timeout' | 'other'`) 와 별개 — `ollama_unreachable.payload.reason` 만 신규 enum 도입 또는 기존 union 확장. spec 단계 결정: **기존 `'unreachable'` 그대로 유지**, 신규 enum 추가 X (단순화). reason 변환 후 prefix 만 변경:
+
+```ts
+const cls = classifyFetchError(e);
+this.telemetry?.emit({ kind: 'ollama_unreachable', payload: { reason: `unreachable:${cls}` } });
+```
+
+**테스트 (4건 신규)**:
+
+- `ECONNREFUSED` → `unreachable:network`
+- `ETIMEDOUT` → `unreachable:timeout`
+- `ENOTFOUND` → `unreachable:dns`
+- 그 외 → `unreachable:other`
+
+### 3-4. KST_OFFSET_MS inline duplication 5 callsite → import (#19)
+
+**현재**: canonical `src/shared/util/kstDate.ts` 가 있는데 5 callsite inline duplicate.
+
+| 파일 | 라인 | 처리 |
+|---|---|---|
+| `src/main/repository/NoteRepository.ts:1042` | inline `const KST_OFFSET_MS = ...` | `import { KST_OFFSET_MS } from '@shared/util/kstDate.js'` |
+| `src/main/repository/ftsHelpers.ts:18` | 동 | 동 |
+| `src/main/services/BackupService.ts:6` | 동 | 동 |
+| `src/main/services/ContinuityService.ts:4` | 동 | 동 |
+| `src/renderer/inbox/components/NoteCard.tsx:30` | 동 | 동 (renderer alias 경계 X — `@shared/...` 양쪽 import 가능) |
+
+**테스트**: 단위 추가 없음 — 기존 회귀 검사. `kstDate.ts` 의 export 가 동일 값 (9 \* 60 \* 60 \* 1000) 이므로 동작 무변화.
+
+---
+
+## 4. Cosmetic / readability (6건)
+
+### 4-1. 탭 ARIA 패턴 정정 (#14)
+
+`aria-pressed` 는 toggle 버튼용. 본 UI 의 탭 (Inbox / 휴지통 / 회고 등) 은 `role="tab"` + `aria-selected` canonical. screen reader 동작 OK 였지만 a11y audit canonical 정정.
+
+**파일**: `src/renderer/inbox/App.tsx` (탭 컨테이너) — grep 으로 `aria-pressed` 위치 확정 후 수정.
+
+**테스트**: 단위 추가 없음 (기존 RTL 단위가 selectable 검증). 단 `aria-selected="true"` 관련 assertion 1건 추가 검증.
+
+### 4-2. `loadExpired()` 미사용 제거 (#18)
+
+`store.ts` 의 `loadExpired()` action 이 `loadInitial`/`refreshMeta` 가 inline fetch 하면서 사용 안 함. App.tsx 호출 0건. test 만 exercise.
+
+**처리**: dead-code 제거. 관련 test 도 제거.
+
+### 4-3. AiWorker per-tag emit `Promise.all` 병렬화 (#32)
+
+**현재**:
+
+```ts
+for (const tag of new Set(...)) {
+  await this.telemetry.emit({ kind: 'tag_vocab_hit' or 'miss', ... });  // serial
+}
+```
+
+**수정**:
+
+```ts
+await Promise.all(
+  Array.from(new Set(...)).map((tag) => this.telemetry.emit({ ... }))
+);
+```
+
+**Risk**: emit 순서 변경 — telemetry 파일 라인 순서 의존 단위 없음 확인. `ai_succeeded` emit 도 serial 이지만 본 cut 은 **per-tag emit 만** 변경 (tag_vocab_hit / tag_vocab_miss). `ai_succeeded` 는 serial 유지 (per-tag 와 다른 호출 시점).
+
+**테스트**: 회귀 단위 PASS 확인. 신규 단위 추가 없음 (병렬 동작 자체 검증은 unit 무리).
+
+### 4-4. `emitRecallShown` / `emitRecallSnoozed` `ipcMain.handle → on` (#36)
+
+`fire-and-forget` 정책 호출 측 (RecallBanner) → return value 사용 안 함. canonical pattern: `ipcMain.on` (return value 없음).
+
+**파일**: `src/main/ipc/inboxApi.ts` 또는 telemetry IPC 정의 위치. `emitRecallShown` / `emitRecallSnoozed` 만 `handle → on` migration. 호출 측 (`window.api.emitRecallShown` 등) 의 `Promise<void>` 시그니처 그대로 (preload 가 `ipcRenderer.send`).
+
+**Risk**: `ipcMain.handle` 의 return value 의존 호출자 grep 으로 0 확인.
+
+**테스트 (1건 신규)**: `vision-ipc.test.ts` 패턴 정합 — `ipcRenderer.send` 호출 검증.
+
+### 4-5. OllamaSettingsModal 폐기 확인 (#41+#42)
+
+**현재 audit**: `grep "OllamaSettingsModal" src/` → 0건. v0.2.7 cut 에서 이미 폐기됨 (memory: "OllamaSettingsModal 제거 + onOpenOllamaSettings 채널 cleanup").
+
+**처리**: backlog 항목 닫기만. **코드 변경 0**. v024-backlog.md 의 #41/#42 처리 이력 ✅ 추가.
+
+### 4-6. Telemetry `.catch(() => {})` silent → debug log (#20)
+
+**현재**: `CaptureService.listExpired` / `trashExpiredBatch` 가 `.catch(() => {})` 로 silent.
+
+**수정**:
+
+```ts
+this.telemetry.emit(...).catch((e) => {
+  this.logger.debug('telemetry.emit.failed', { reason: String(e) });
+});
+```
+
+`logger.debug` (project pattern) — production noise 0, 디버그 시 reproduce 가능.
+
+**테스트**: 단위 추가 없음. 회귀 PASS.
+
+---
+
+## 5. 기록 정리 (2건)
+
+### 5-1. v0.2.2 stale memory 폐기
+
+`~/.claude/projects/c--Users-rlaxo-inkling/memory/project_v022_feedback.md` — 6건 모두 v0.2.3~v0.2.9 cut 들에서 처리됨 (Ollama 회복 / AI 영속 큐 / 태그 vocab / 휴지통 / 만료 추천 / RecallBanner). 8일 stale.
+
+**처리**:
+
+- 파일 삭제
+- `MEMORY.md` 의 line 8 (`- [v0.2.2 feedback]...`) 제거
+
+### 5-2. v024-backlog.md 갱신
+
+처리 이력 table 에 신규 12건 entry 추가:
+
+```markdown
+| #14 (탭 ARIA) | ✅ 처리 | v0.3.2 |
+| #18 (loadExpired 미사용) | ✅ 처리 | v0.3.2 |
+| #19 (KST inline 5 callsite 잔여) | ✅ 처리 | v0.3.2 |
+| #20 (.catch silent → debug log) | ✅ 처리 | v0.3.2 |
+| #31 (vocabSet COLLATE) | ✅ 처리 | v0.3.2 |
+| #32 (per-tag Promise.all) | ✅ 처리 | v0.3.2 |
+| #36 (recall IPC handle→on) | ✅ 처리 | v0.3.2 |
+| #39 (PII reason 마스킹) | ✅ 처리 | v0.3.2 |
+| #41+#42 (OllamaSettingsModal 폐기) | ✅ 자연 소멸 (v0.2.7) | v0.3.2 audit |
+| time-dependent test flake | ✅ 처리 | v0.3.2 |
+```
+
+총 처리 22 → 32, 잔여 23 → 11 (data-dependent 9 + future-proof 2).
+
+---
+
+## 6. 보류 항목 (dogfood 후 재평가)
+
+### data-dependent (9건)
+
+- #25 HealthChecker `inFlight` manual emit ordering — dogfood soak 결과 결정 (1초 윈도우 dedup 필요 여부)
+- #29 `getTopUsedTags(20)` magic number → `VOCAB_TOP_N` 모듈 상수 (이미 #29 처리, 튜닝 자체는 telemetry 후)
+- #30 `getTopUsedTags` SQL-side 필터 (overfetch+slice vs `GLOB`) — vocab pool 확장 결정
+- #33 `PROMPT_VERSION` telemetry payload 추가 — prompt 튜닝 후 hit-rate 추적 시
+- #35 `recall_shown` per-banner-lifetime dedup — telemetry 빈도 보고
+- #40 Settings 저장 vs HealthChecker race — visible 빈도 확인
+- #16 per-note 영구 삭제 telemetry 빈도 — 거의 0 이면 bulk emptyTrash 만 (UX 단순화)
+- #28 `unreachableBackoffStep` job-level — multi-provider 도입 시
+- recall_shown lifetime 영속 마커 (data-dependent #35 와 일부 중복)
+
+### future-proof / cross-cutting (4건)
+
+- #27 `refreshTrayFailedCount` exported singleton → TrayController class — multi-window 가설 검증 X
+- #24+#41 Banner CSS variables — modal 폐기로 일부 자연 소멸 + 잔여 4 banner 의 hardcode 색상은 단일 dogfood UX 영향 0
+- #37 NoteCard `id="note-${id}"` ref-forwarding — search 결과 scroll 등 신규 surface 등장 시
+- #28 단일 카운터 vs job-level — multi-provider 진입 시점
+
+---
+
+## 7. 테스트 전략
+
+| 영역 | 단위 |
+|---|---|
+| `vocabSet` lowercase normalize | 3 (대/소문자 vocab × AI tag matrix) |
+| `NoteRepository.create(now)` param | 2 (default / 명시 주입) |
+| `NoteRevisions.test.ts` flake fix | 4 testcase 회복 (v1 capture 시간 주입) |
+| `upsertFromSync.test.ts` flake fix | 2 testcase 회복 |
+| PII reason classification | 4 (network/timeout/dns/other) |
+| KST inline → import migration | 회귀 PASS 확인 (단위 +0) |
+| 탭 ARIA `aria-selected` | 1 신규 assertion |
+| `loadExpired` 제거 | 회귀 (test 같이 제거) |
+| AiWorker `Promise.all` 회귀 | 회귀 PASS |
+| recall IPC `on` migration | 1 신규 (`ipcRenderer.send` 검증) |
+| Telemetry `.catch` debug log | 회귀 PASS |
+
+목표: 단위 710 → **약 720** (+10 신규, -2 제거 [`loadExpired` test], net +8). typecheck 0.
+
+---
+
+## 8. Risk
+
+| Risk | 대응 |
+|---|---|
+| `NoteRepository.create(now)` signature 변경 호출자 영향 | optional + default = `new Date()`. 기존 호출자 0 무영향. typecheck 가 누락 catch |
+| KST inline → import 회귀 (값 다른 정의) | canonical export 값 (9 \* 60 \* 60 \* 1000) 동일 검증. 기존 단위 회귀 PASS = 알고리즘 동일 |
+| `ipcMain.handle → on` migration 시 return value 의존 호출자 누락 | grep 으로 호출자 enumerated. preload 시그니처 그대로 (`Promise<void>`) — 호출 측 무수정 |
+| AiWorker `Promise.all` 으로 emit 순서 변경 | telemetry 파일 라인 순서 의존 단위 0 확인. file-append round-trip 만 줄어듦 |
+| PII 마스킹으로 디버그 어려움 | error class enum + production reproduce 시 dev 환경에서 stack 그대로 노출 (telemetry 만 마스킹) |
+| time-dependent fix 시 다른 시간 의존 단위 발견 | grep `new Date()` in `repo` methods → `create` 외 다른 메서드 audit. 발견 시 spec 갱신 X (cleanup cut 외 deferred) |
+
+---
+
+## 9. v0.3.2 후
+
+**Cut G** (v0.3.3 또는 v0.4.0 — F25 사이드바 + notebook_id) 진입 전:
+
+- v0.3.2 release → main → tag → Windows exe + Gitea release
+- macOS host 핸드오프: dist:mac dmg + dist:linux AppImage/deb (v0.3.0 + v0.3.1 + v0.3.2 누적 backlog)
+- **다기기 종합 dogfood ≥1주 soak**:
+  - sync (Cut E): 충돌 빈도 / 인증 흐름 / interval 적정성 / NTP 단조 가정
+  - vision (Cut F): 이미지 capture 빈도 / 한국어 정확도 / capability detection 정확도
+  - cleanup (Cut 본 v0.3.2): 잠재 bug 회귀 X 확인
+- soak 후 신규 발견 + data-dependent 9건 일괄 triage → Cut G brainstorm 진입
+
+**Cut G 가설** (재검증):
+
+1. inbox 단일 view 의 정보 밀도 한계 (현재 노트 누적 N건 = 스크롤 부담)
+2. notebook 카테고리 = 분류 hint vs 단일 inbox + 태그 필터로 충분
+3. 사이드바 = 새 surface = 기존 정책 (트레이 deemphasis / SettingsPage 우선) 재고

docs/superpowers/specs/2026-05-14-v04-notebooks-lifecycle-design.md

@@ -0,0 +1,327 @@
+# v0.4 — Notebooks + Lifecycle Simplification Design
+
+**작성일:** 2026-05-14
+**선행 문서:**
+
+- `docs/superpowers/specs/2026-04-25-dogfood-feedback.md` F25 (raw idea)
+- `docs/superpowers/specs/2026-05-09-v032-cut-g-design.md` (v0.3.2 Cut G — **deprecate**, 본 문서로 승격)
+- `docs/superpowers/strategy/v028plus-roadmap.md` Cut G position
+
+---
+
+## 1. 정체성
+
+inbox 분류 layer 도입 + lifecycle 단순화. 단일 cut 으로 묶음 — 두 변경이 같은 UI 영역 (헤더 탭 + status 모델) 을 동시 손대므로 분리 시 중간 상태가 어색.
+
+- **분류 (notebook)**: cross-cutting 컨텍스트. "회사" / "개인" / "학습" 같은 공간 구분. 단일 DB 안 `notebook_id` 컬럼 (옵션 B — Cut G 결정 승계).
+- **lifecycle 단순화**: status 4분기 → 3분기. `archived` 제거.
+
+---
+
+## 2. dogfood 근거 (왜 이 시점에 이 cut)
+
+2026-04-25 ~ 2026-05-14 (19일) telemetry + DB:
+
+| 신호 | 수치 | 의미 |
+|------|------|------|
+| `archived` 노트 | 0건 | 4분기 lifecycle 중 1차원 dead — 사용자가 한 번도 사용 안 함 |
+| `active` 노트 | 10건 | 사용 중 |
+| `completed` 노트 | 8건 | 적극 사용 |
+| `trashed` 노트 | 20건 | 적극 사용 |
+| top tag `mlx-ops` | 6건 | 단일 tag 가 사실상 "MLX팀 메모" 컨텍스트 그룹 역할 — tag 의 분류 욕구 명확 |
+| tag vocab 적중률 | 32.8% (19/58) | 새 tag 빈번 생성 — 분류 욕구 일관성 부족, grouping UI 필요 |
+
+→ **archived 는 제거 안전** (마이그레이션 영향 0건). **분류 욕구는 데이터로 확인**되었으나 tag 만으로 충족 어려움 (적중률 낮음).
+
+사용자 우려 ("분류 × lifecycle 햇갈림") 의 대응: archived 제거로 한 차원 줄임. 결과 layer = (notebook × 3분기 × tag) — 3차원이지만 archived 0건 빼서 정신 부담 줄음.
+
+---
+
+## 3. 범위
+
+| 항목 | 결정 |
+|------|------|
+| **분류 모델** | 옵션 B — `notebook_id` 카테고리, 단일 DB. 옵션 A (다중 profile + 비밀번호 잠금) 는 v0.5+ 후보. |
+| **lifecycle 차원** | 3분기 — `active` (inbox) / `completed` (완료) / `trashed` (휴지통). `archived` 제거. |
+| **default notebook** | 마이그레이션 시 "기본" 1개 자동 생성. 모든 기존 노트 배치. |
+| **사이드바 가시성** | 사용자 토글 + last state (`settings.sidebar_visible`). Cmd+B / Ctrl+B 단축키. |
+| **사이드바 내용** | 상단 notebook 목록 + 하단 메모 list (compact view, current notebook + current view 필터). |
+| **사이드바 폭** | default 240px, `settings.sidebar_width` 조정 가능 (180-400). |
+| **notebook 삭제** | FK RESTRICT — 메모 잔류 시 throw. UI 가 "메모 N건 이동 후 재시도" 안내. |
+| **search scope** | 기본 current notebook, 사용자가 dropdown 으로 "모든 노트북" 전환 가능. |
+| **새 capture 의 notebook** | current `selectedNotebookId`. 사용자가 다른 notebook 에 있으면 거기 저장. |
+
+---
+
+## 4. Schema 마이그레이션 (m008)
+
+```sql
+-- 1. notebooks 테이블 생성
+CREATE TABLE notebooks (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  color TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+CREATE UNIQUE INDEX idx_notebooks_name ON notebooks(name);
+
+-- 2. notes.notebook_id 추가 (FK, NOT NULL — default 통해 보장)
+ALTER TABLE notes ADD COLUMN notebook_id TEXT
+  REFERENCES notebooks(id) ON DELETE RESTRICT;
+
+-- 3. default notebook "기본" 생성
+INSERT INTO notebooks (id, name, created_at, updated_at)
+  VALUES ('<uuidv7>', '기본', '<now>', '<now>');
+
+-- 4. 모든 기존 노트를 default notebook 에 배치
+UPDATE notes SET notebook_id = '<default-id>' WHERE notebook_id IS NULL;
+
+-- 5. NOT NULL 제약 추가 (마이그레이션 후)
+-- SQLite ALTER 제약: 새 테이블 만들고 복사 패턴 사용 (better-sqlite3 표준)
+
+-- 6. archived → completed 정리 (실제 0건이라 no-op, 안전 위해 명시)
+UPDATE notes SET status = 'completed' WHERE status = 'archived';
+
+-- 7. status CHECK constraint 갱신: archived 제거
+-- 마찬가지로 새 테이블 만들고 복사 패턴
+```
+
+마이그레이션 안전성: 기존 archived 노트 0건 확인 (telemetry + DB query). default notebook 자동 생성으로 기존 사용자 영향 없음.
+
+---
+
+## 5. NotebookRepository
+
+```ts
+interface Notebook {
+  id: string;
+  name: string;
+  color: string | null;
+  createdAt: string;
+  updatedAt: string;
+  noteCount: number;  // active 노트만 (trashed 제외)
+}
+
+class NotebookRepository {
+  list(): Notebook[];                                // count 포함, name ASC
+  findById(id: string): Notebook | null;
+  create(input: { name: string; color?: string }): Notebook;
+  rename(id: string, name: string): void;            // UNIQUE name violation throw
+  setColor(id: string, color: string | null): void;
+  delete(id: string): { ok: true } | { ok: false; reason: 'has_notes' };
+  // 메모 잔류 시 FK RESTRICT throw → ok:false 변환
+
+  moveNote(noteId: string, notebookId: string): void;
+  countByNotebook(): Map<string, number>;            // 한번 호출로 전체 count
+}
+```
+
+---
+
+## 6. UI — 사이드바
+
+```
+┌───────────────┬─────────────────────────────────────┐
+│ [≡] Inkling   │ [Inbox(N) 완료(N) 휴지통(N)] [🔍] [⚙] │
+├───────────────┼─────────────────────────────────────┤
+│ ● 기본 (5)    │                                     │
+│ ● 회사 (12)   │    NoteCard list (main pane)        │
+│ ● 학습 (3)    │                                     │
+│ + 새 노트북   │                                     │
+│ ─────         │                                     │
+│ 메모 빠른 list │                                     │
+│ ・제목1       │                                     │
+│ ・제목2 #tag  │                                     │
+│ ・제목3       │                                     │
+└───────────────┴─────────────────────────────────────┘
+```
+
+- 좌측, 폭 240px (사용자 조정 가능)
+- 헤더 좌측 `≡` 클릭 → 토글. 단축키 `Cmd+B` / `Ctrl+B`
+- 상단: notebook 목록 (active 노트 count badge). 클릭 → `selectedNotebookId` 변경
+- "+ 새 노트북" 클릭 → NotebookCreateModal (name + optional color)
+- 노트북 우클릭 / hover icon → rename / color 변경 / delete
+- 하단: 메모 list — `selectedNotebookId` + `selectedView` (status 탭) 필터 결과의 compact view. 클릭 → main pane 의 noteCard 로 scroll.
+
+---
+
+## 7. UI — lifecycle 단순화
+
+| 변경 | 내용 |
+|------|------|
+| 헤더 탭 | "Inbox / 완료 / 보관 / 휴지통" → **"Inbox / 완료 / 휴지통"** (3탭) |
+| MoveStatusModal | "보관" 옵션 제거. 사용자 선택지: "완료" / "휴지통" (또는 "복원" — trash mode 에서) |
+| countsByStatus IPC | `archived` 필드 제거. 기존 호출자 (헤더 badge) 적용 |
+| NoteRepository.setStatus | `archived` 인자 받으면 throw (defensive). 마이그레이션 후 호출자 없음 |
+| 데이터 호환성 | 기존 archived 노트 0건이라 마이그레이션 단계에서 `completed` 로 일괄 이동 |
+
+---
+
+## 8. store / IPC
+
+```ts
+interface InboxStore {
+  notebooks: Notebook[];
+  selectedNotebookId: string | null;  // null = "모든 노트북" 검색 결과 등 특수 모드
+  sidebarVisible: boolean;
+  sidebarWidth: number;
+  loadNotebooks: () => Promise<void>;
+  selectNotebook: (id: string) => void;
+  createNotebook: (name: string, color?: string) => Promise<{ ok: boolean; reason?: string }>;
+  renameNotebook: (id: string, name: string) => Promise<{ ok: boolean; reason?: string }>;
+  setNotebookColor: (id: string, color: string | null) => Promise<void>;
+  deleteNotebook: (id: string) => Promise<{ ok: boolean; reason?: string }>;
+  moveNoteToNotebook: (noteId: string, notebookId: string) => Promise<void>;
+  toggleSidebar: () => void;
+}
+```
+
+IPC channels (신설):
+- `notebook:list` / `notebook:create` / `notebook:rename` / `notebook:set-color` / `notebook:delete`
+- `notebook:move-note`
+
+기존 변경:
+- `inbox:list` / `inbox:list-by-status` 에 `notebookId?` 옵션 추가 (없으면 모든 노트북)
+- `inbox:counts-by-status` 도 `notebookId?` 옵션 + `archived` 필드 제거
+
+---
+
+## 9. search 통합
+
+- 기본 scope: `selectedNotebookId` 안 검색
+- search box 옆 dropdown: "이 노트북" / "모든 노트북"
+- `inbox:search` 에 `notebookId?` 옵션 추가
+- search 결과 NoteCard 가 notebook 표시 (모든 노트북 검색 시) — 작은 색 chip + 이름
+
+---
+
+## 10. sync 영향 (Cut E 이후)
+
+- export 시 frontmatter 에 `notebook` 필드 추가 (이름 — 다기기 간 id 충돌 회피)
+- import 시 notebook 이름이 없으면 생성, 있으면 reuse
+- 충돌: 같은 이름 + 다른 id 면 import side 의 id 우선 (deterministic)
+
+---
+
+## 11. AI × Notebook 통합
+
+### 11-1. fit 매칭 (매 capture)
+
+- `buildPrompt` 가 현재 notebooks 목록 (이름) 을 prompt 에 포함
+- AI 응답 JSON 에 `notebook_match` 필드 (기존 notebook 이름 또는 null) 추가
+- schema (Zod) 갱신: `notebook_match: z.string().nullable().optional()`
+- 매치 성공 시 자동 배치 (Zero-Effort 가치 우선). NoteCard 의 notebook chip 클릭으로 1-click 변경 가능
+- 매치 실패 / null → default "기본" notebook
+
+prompt 추가 라인 예시 (한국어 자연어):
+
+```
+사용 가능한 노트북: 기본, 회사, 학습
+이 노트가 위 노트북 중 하나에 명확히 속하면 그 이름을 "notebook_match" 에 반환. 그렇지 않으면 null.
+새 노트북 이름을 만들지 말 것 — 기존 목록 안에서만 선택.
+```
+
+### 11-2. promotion 제안
+
+**trigger** — 같은 tag 가 **active 노트 안 3건 이상** 누적되고 그 노트들이 모두 default "기본" notebook 에 있을 때 (`active` + `notebook_id = default` + 동일 tag).
+
+분석 timing — inbox 열릴 때 lazy. 단순 SQL aggregation 이라 cost 무시 가능.
+
+```sql
+SELECT t.name, COUNT(DISTINCT n.id) AS cnt
+  FROM tags t
+  JOIN note_tags nt ON nt.tag_id = t.id
+  JOIN notes n ON n.id = nt.note_id
+ WHERE n.status = 'active'
+   AND n.notebook_id = '<default-id>'
+ GROUP BY t.id
+HAVING cnt >= 3
+```
+
+매치 발생 시 InboxStore 에 `promotionCandidate: { tag, noteIds, suggestedName }` 채움. banner 가 표시.
+
+**v0.4 first release 는 rule only** — LLM 의 semantic cluster 분석은 cost 큼. dogfood 결과 보고 v0.5+ 검토.
+
+### 11-3. UI — PromotionBanner
+
+- Inbox 상단, RecallBanner / ExpiryBanner 와 같은 위치
+- 문구 예: "💡 `mlx-ops` 관련 노트 6개가 모였어요. 새 노트북 **MLX Ops** 로 분리할까요?"
+- 액션: `[수락]` `[나중에]` `[숨기기]`
+- 수락 → 작은 modal 띄움 (이름 inline 수정 + color 선택) → notebook 생성 + 해당 noteIds 일괄 이동 + 사이드바 자동 열어 새 notebook 가시화
+- 나중에 → 24h snooze (RecallBanner 패턴)
+- 숨기기 → 해당 tag 영구 dismiss (`settings.promotion_dismissed_tags` array)
+
+### 11-4. notebook 이름 generation
+
+- default: tag 이름을 Title Case 변환 (예: `mlx-ops` → `MLX Ops`, `user-management` → `User Management`)
+- 사용자가 수락 modal 에서 inline 수정 가능
+
+### 11-5. promotion 후 status 보존
+
+- 이동된 노트의 `status` 그대로 유지 (active → active, completed → completed)
+- `notebook_id` 만 변경
+
+### 11-6. 새 노트의 자동 fit 매칭이 promoted notebook 도 인식
+
+- promotion 후 notebooks 목록에 새 notebook 포함 → 다음 capture 의 prompt 에 자동 반영
+- 그 후 같은 주제 노트는 자동으로 새 notebook 에 들어감
+
+---
+
+## 12. 테스트 전략
+
+| 영역 | 케이스 |
+|------|--------|
+| NotebookRepository | CRUD + count + delete RESTRICT |
+| migration m008 | default notebook 생성 + 기존 노트 마이그레이션 + archived → completed |
+| store actions | 토글 + 선택 변경 + create/rename/delete 흐름 |
+| UI 사이드바 | notebook 목록 render + 클릭 selectedNotebookId 변경 + count badge |
+| 메모 list 필터 | notebook + view 필터 combination |
+| search scope | current / all 옵션별 결과 |
+| MoveStatusModal | archived 옵션 부재 |
+| 헤더 탭 | 3탭 + count |
+| AI prompt notebook_match | prompt 에 notebooks 목록 포함 + AI 응답 schema 의 notebook_match 필드 |
+| capture 자동 fit | AI 응답 notebook_match 매치 시 자동 배치, 미매치 시 default |
+| promotion query | tag 3건 이상 + default notebook 클러스터 검출 |
+| PromotionBanner | 수락 → notebook 생성 + 일괄 이동 / 나중에 → 24h snooze / 숨기기 → tag dismiss 영구 저장 |
+
+---
+
+## 13. risks
+
+| risk | 대응 |
+|------|------|
+| migration 의 status check constraint 갱신 실패 | SQLite 새 테이블 복사 패턴 + 검증 query 후 commit |
+| 좁은 화면 (1280×720) 에서 사이드바 부담 | settings.sidebar_visible default false (사용자가 켜야 보임) |
+| notebook 삭제 시 RESTRICT error UX | "메모 N건 이동 후 다시 시도" + 이동 dialog 제공 |
+| sync (Cut E) 와 결합 시 notebook 정합성 | frontmatter notebook 이름 기반 — 다기기 간 ID 충돌 회피 |
+| tag 와 notebook 의미 혼동 | UI text 명시: "노트북 = 컨텍스트 (회사 / 개인)", "태그 = 주제 키워드 (mlx-ops, keycloak)" — 설정 페이지 도움말에 안내 |
+| 사용자가 다중 notebook 실제 안 만들면 default 1개 + 사이드바 = noise | default sidebar hidden + 사용자가 2번째 notebook 만들 때 자동 reveal hint |
+| AI 가 notebook_match 에 새 이름 ad-hoc 생성 시도 | prompt 에 "기존 목록 안에서만 선택, 새 이름 만들지 말 것" 명시 + schema 검증 단계에서 notebooks 목록과 매치 안 되는 값은 null 로 coerce |
+| 같은 tag 의 promotion 이 반복 노출되어 사용자 피로 | "숨기기" → 영구 dismiss (settings 의 array). RecallBanner 의 24h snooze 와 별개 영구 저장소 |
+
+---
+
+## 14. 게이트
+
+- 단위 테스트 — notebook CRUD + migration + UI 사이드바 + 메모 list 필터 + status 3분기 회귀 + AI fit/promotion 분기
+- 마이그레이션 verify — fresh DB + 기존 DB 두 시나리오에서 default notebook 생성 + archived 정리
+- dogfood — 2-3 일 후 (1) 사이드바 열려있는 비율, (2) notebook 갯수 (수동 vs promoted), (3) notebook 간 메모 이동 빈도, (4) promotion 수락률 측정
+
+---
+
+## 15. 작업 분해 (writing-plans 입력)
+
+1. **m008 마이그레이션** — notebooks 테이블 + notes.notebook_id + archived 정리 + status enum
+2. **NotebookRepository** + IPC 핸들러
+3. **NoteRepository** 변경 — notebook_id 필터, list/search/counts 옵션 확장
+4. **store** — notebooks state + actions + promotionCandidate state
+5. **AI prompt 변경** — buildPrompt 에 notebooks 목록 주입, schema 의 notebook_match 필드, AiWorker 가 응답 매치하여 자동 배치 (또는 default 로 coerce)
+6. **promotion 분석** — NoteRepository.findPromotionCandidates 쿼리 + store action (inbox open 시 lazy)
+7. **PromotionBanner UI** — Inbox 상단, 수락 modal, 24h snooze, 영구 dismiss
+8. **사이드바 UI** — Sidebar.tsx + NotebookList + NotebookCreateModal
+9. **헤더 / MoveStatusModal** — archived 제거
+10. **search** — scope 옵션 통합
+11. **sync (옵션 deferred)** — frontmatter notebook 필드. v0.4 본체 머지 후 별도 작업으로 가능
+12. **CHANGELOG + release notes** — dogfood 근거 명시

docs/superpowers/v024-backlog.md

@@ -3,9 +3,9 @@
 > 누적 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)
+**최종 갱신:** 2026-05-10 (v0.3.2 cleanup cut — 잠재 bug 4 + cosmetic 5 + #20 deferred)
 **총 항목 수:** 46 (#1 stale 포함)
-**잔여:** 23건 (=46 − 처리 22 − stale 1)
+**잔여:** 14건 (=46 − 처리 31 − stale 1)
 
 ## 처리 이력 / 진행 흐름
 
@@ -39,6 +39,21 @@
 |---|---|---|
 | **B1 production path** (CaptureService.restoreNote 가 옛 `repo.restore` 호출) | ✅ Critical fix (commit `a991008`) | v0.2.6 round 1 |
 
+### v0.3.2 cleanup cut (2026-05-10)
+
+| 항목 | 상태 | Cut |
+|---|---|---|
+| #14 (탭 ARIA `aria-pressed`→`role="tab"`) | ✅ 처리 | v0.3.2 |
+| #18 (`loadExpired` 미사용 제거) | ✅ 처리 | v0.3.2 |
+| #19 (KST inline 5 callsite 잔여 migrate) | ✅ 처리 | v0.3.2 |
+| #20 (telemetry `.catch` silent → debug log) | 🟡 deferred (CaptureService logger 미주입 — constructor 변경 회피) | v0.3.2 audit |
+| #31 (vocabSet COLLATE NOCASE 정합) | ✅ 처리 | v0.3.2 |
+| #32 (per-tag emit `Promise.all` 병렬화) | ✅ 처리 | v0.3.2 |
+| #36 (recall IPC `handle`→`on`) | ✅ 처리 | v0.3.2 |
+| #39 (`ollama_unreachable.reason` PII 마스킹) | ✅ 처리 | v0.3.2 |
+| #41+#42 (`OllamaSettingsModal` 폐기 audit) | ✅ 자연 소멸 (v0.2.7) | v0.3.2 audit |
+| time-dependent test flake fix | ✅ 처리 | v0.3.2 |
+
 ### v0.2.6 final reviewer + round 1 minors (deferred)
 
 | 항목 | 상태 |

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "inkling",
-  "version": "0.2.10",
+  "version": "0.3.14",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "inkling",
-      "version": "0.2.10",
+      "version": "0.3.14",
       "dependencies": {
         "better-sqlite3": "12.9.0",
         "electron-log": "5.2.0",
@@ -3232,7 +3232,7 @@
       }
     },
     "node_modules/@tokenizer/token": {
-      "version": "0.3.0",
+      "version": "0.3.1",
       "resolved": "https://registry.npmjs.org/@tokenizer/token/-/token-0.3.0.tgz",
       "integrity": "sha512-OvjF+z51L3ov0OyAU0duzsYuvO01PH7x4t6DJx+guahgTnBHkhJdG7soQeTSFLWN3efnHyibZ4Z8l2EuWwJN3A==",
       "dev": true,

package.json

@@ -1,6 +1,6 @@
 {
   "name": "inkling",
-  "version": "0.2.10",
+  "version": "0.4.0",
   "private": true,
   "description": "Inkling — local-first 한 줄 보관 도구",
   "author": "altair823 <dlsrks0734@gmail.com>",

src/main/ai/AiWorker.ts

@@ -1,6 +1,10 @@
+import { readFile } from 'node:fs/promises';
 import type { NoteRepository } from '../repository/NoteRepository.js';
+import type { NotebookRepository } from '../repository/NotebookRepository.js';
 import type { Note } from '@shared/types';
 import type { AiFailedReason } from '../services/telemetryEvents.js';
+import type { SettingsService } from '../services/SettingsService.js';
+import type { MediaStore } from '../services/MediaStore.js';
 import { ProviderHolder } from './ProviderHolder.js';
 import { parseAllCandidates } from '../services/dueDateParser.js';
 import { ZodError } from 'zod';
@@ -41,6 +45,12 @@ export interface AiWorkerOptions {
   };
   now?: () => Date;
   telemetry?: AiTelemetryEmitter;
+  /** v0.3.1 Cut F — vision 지원. 미전달 시 vision 비활성. */
+  settings?: Pick<SettingsService, 'getVisionModel'>;
+  /** v0.3.1 Cut F — 첨부 이미지 절대경로 변환. settings 와 함께 전달 시 vision 활성. */
+  mediaStore?: Pick<MediaStore, 'absolutePath'>;
+  /** v0.4 — AI 응답의 notebook_match 처리용. 미전달 시 notebook 매칭 skip. */
+  notebookRepo?: Pick<NotebookRepository, 'list' | 'findByName' | 'moveNote'>;
 }
 
 interface Job { noteId: string; attempts: number; }
@@ -56,6 +66,9 @@ export class AiWorker {
   private logger: NonNullable<AiWorkerOptions['logger']>;
   private now: () => Date;
   private telemetry?: AiTelemetryEmitter;
+  private settings?: Pick<SettingsService, 'getVisionModel'>;
+  private mediaStore?: Pick<MediaStore, 'absolutePath'>;
+  private notebookRepo?: Pick<NotebookRepository, 'list' | 'findByName' | 'moveNote'>;
 
   constructor(
     private repo: NoteRepository,
@@ -68,6 +81,9 @@ export class AiWorker {
     this.logger = opts.logger ?? { info: () => {}, warn: () => {}, error: () => {} };
     this.now = opts.now ?? (() => new Date());
     this.telemetry = opts.telemetry;
+    this.settings = opts.settings;
+    this.mediaStore = opts.mediaStore;
+    this.notebookRepo = opts.notebookRepo;
   }
 
   async enqueue(noteId: string): Promise<void> {
@@ -126,14 +142,57 @@ export class AiWorker {
         const nowDate = this.now();
         const todayDate = kstTodayAsDate(nowDate);
         const todayIso = kstTodayIso(nowDate);
+
+        // v0.3.14 — 본문 빈 + 이미지만 첨부 케이스는 모델이 의미 있는 응답 못 함
+        // (gemma4:26b 등 vision 모델의 한계 확인). AI 호출 skip, 자동 placeholder 적용 후
+        // 즉시 done. 사용자가 후에 NoteCard 의 EditableField 로 제목/요약 편집 가능.
+        const rawEmpty = note.rawText.trim().length === 0;
+        if (rawEmpty && note.media.length > 0) {
+          const n = note.media.length;
+          const title = n === 1 ? '첨부 이미지' : `첨부 이미지 ${n}장`;
+          const summary = `이미지 ${n}장이 첨부된 메모입니다.\n원문 영역에서 이미지 확인할 수 있습니다.\n제목과 요약을 클릭해 직접 편집할 수 있습니다.`;
+          this.repo.updateAiResult(job.noteId, {
+            title, summary, tags: [], provider: 'image-only-skip', dueDate: null
+          });
+          this.logger.info('ai.skip.image-only', { noteId: job.noteId, mediaCount: n });
+          this.emit(job.noteId);
+          return;
+        }
+
         const candidates = parseAllCandidates(note.rawText, todayDate);
         const vocab = this.repo.getTopUsedTags(VOCAB_TOP_N);
-        const res = await this.holder.get().generate({
-          text: note.rawText,
-          todayKst: todayIso,
-          dueDateCandidates: candidates,
-          vocab
+        // v0.3.1 Cut F — vision path: visionModel + note.media → base64 images
+        // final review fix: note.media[].bytes 로 fast-fail (readFile/base64 비용 회피).
+        // 5MB cap 초과 시 throw → AiWorker 의 'other' 분기 → markAiFailed 도달.
+        const visionModel = this.settings ? await this.settings.getVisionModel() : null;
+        let images: Array<{ base64: string; mime: string }> | undefined;
+        const visionActive = !!(visionModel && note.media.length > 0 && this.mediaStore);
+        // v0.3.14 — vision 활성 여부 진단 로그. 사용자가 vision_model 미설정으로 text-only
+        // path 가 도는지 / 이미지가 모델에 전달되는지 확인 가능 (logs/main.log).
+        this.logger.info('ai.vision.decide', {
+          noteId: job.noteId,
+          visionActive,
+          visionModelConfigured: !!visionModel,
+          mediaCount: note.media.length,
+          mediaStorePresent: !!this.mediaStore
         });
+        if (visionActive) {
+          const oversize = note.media.find((m) => m.bytes > 5 * 1024 * 1024);
+          if (oversize) {
+            throw new Error(`image ${oversize.relPath} exceeds 5MB cap (${oversize.bytes} bytes)`);
+          }
+          images = await Promise.all(
+            note.media.map(async (m) => {
+              const buf = await readFile(this.mediaStore!.absolutePath(m.relPath));
+              return { base64: buf.toString('base64'), mime: m.mime };
+            })
+          );
+        }
+        const notebookNames = this.notebookRepo ? this.notebookRepo.list().map((nb) => nb.name) : [];
+        const res = await this.holder.get().generate(
+          { text: note.rawText, images, todayKst: todayIso, dueDateCandidates: candidates, vocab, notebooks: notebookNames },
+          { visionModel: visionModel ?? undefined }
+        );
         // AI primary: AI's dueDate is final (no rule merge)
         this.repo.updateAiResult(job.noteId, {
           title: res.title,
@@ -142,6 +201,16 @@ export class AiWorker {
           provider: this.holder.get().name,
           dueDate: res.dueDate ?? null
         });
+        // AI 의 notebook_match 가 valid 이름이면 자동 이동.
+        if (res.notebookMatch && this.notebookRepo) {
+          const nb = this.notebookRepo.findByName(res.notebookMatch);
+          if (nb) {
+            this.notebookRepo.moveNote(job.noteId, nb.id);
+            this.logger.info('ai.notebook.match', { noteId: job.noteId, notebook: nb.name });
+          } else {
+            this.logger.info('ai.notebook.miss', { noteId: job.noteId, attempted: res.notebookMatch });
+          }
+        }
         this.unreachableBackoffStep = 0;  // 성공 시 step reset
         this.logger.info('ai.done', {
           noteId: job.noteId,
@@ -150,7 +219,8 @@ export class AiWorker {
           candidatesCount: candidates.length
         });
         if (this.telemetry) {
-          await this.telemetry.emit({
+          const telemetry = this.telemetry;
+          await telemetry.emit({
             kind: 'ai_succeeded',
             payload: {
               noteId: job.noteId,
@@ -160,23 +230,25 @@ export class AiWorker {
           }).catch(() => {});
           // v0.2.3 #3 — per-tag vocab hit/miss 분류 (updateAiResult 후 → tagId 보장)
           // dedup: AI 응답에 같은 태그 중복 가능 — INSERT OR IGNORE 와 정합한 1-emit/태그 보장
-          const vocabSet = new Set(vocab);
-          for (const tagName of new Set(res.tags)) {
-            if (vocabSet.has(tagName)) {
-              const tagId = this.repo.getTagIdByName(tagName);
-              if (tagId !== null) {
-                await this.telemetry.emit({
-                  kind: 'tag_vocab_hit',
-                  payload: { tagId, vocabSize: vocab.length }
+          const vocabSet = new Set(vocab.map((v) => v.toLowerCase()));
+          await Promise.all(
+            Array.from(new Set(res.tags)).map(async (tagName) => {
+              if (vocabSet.has(tagName.toLowerCase())) {
+                const tagId = this.repo.getTagIdByName(tagName);
+                if (tagId !== null) {
+                  await telemetry.emit({
+                    kind: 'tag_vocab_hit',
+                    payload: { tagId, vocabSize: vocab.length }
+                  }).catch(() => {});
+                }
+              } else {
+                await telemetry.emit({
+                  kind: 'tag_vocab_miss',
+                  payload: { vocabSize: vocab.length }
                 }).catch(() => {});
               }
-            } else {
-              await this.telemetry.emit({
-                kind: 'tag_vocab_miss',
-                payload: { vocabSize: vocab.length }
-              }).catch(() => {});
-            }
-          }
+            })
+          );
         }
         this.emit(job.noteId);
         return;
@@ -204,8 +276,13 @@ export class AiWorker {
         const nextRunAt = new Date(Date.now() + (this.backoffsMs[attempt + 1] ?? 0)).toISOString();
         this.repo.incrementJobAttempt(job.noteId, nextRunAt, msg);
         if (isLast) {
-          this.repo.markAiFailed(job.noteId, msg);
-          this.logger.error('ai.failed', { noteId: job.noteId, err: msg });
+          // v0.3.14 — ai_error 에 reason + provider name prefix 추가. NoteCard 의 "원인 보기"
+          // 가 사용자에게 보여주는 raw 메시지에 context (timeout/unreachable/schema/other +
+          // 어느 모델이 fail 했는지) 가 포함되어 진단성 향상.
+          const provider = this.holder.get().name;
+          const annotated = `[${reason}] ${provider}\n${msg}`;
+          this.repo.markAiFailed(job.noteId, annotated);
+          this.logger.error('ai.failed', { noteId: job.noteId, err: msg, reason, provider });
           if (this.telemetry) {
             await this.telemetry.emit({
               kind: 'ai_failed',

src/main/ai/InferenceProvider.ts

@@ -6,13 +6,21 @@ export interface GenerateInput {
   todayKst: string; // ISO YYYY-MM-DD in KST
   dueDateCandidates: ParseResult[];
   vocab?: string[]; // v0.2.3 #3 — top-N kebab-case 태그. 미전달 시 빈 배열로 처리.
+  // v0.3.1 Cut F — 첨부 이미지. 미전달 시 텍스트 전용 처리.
+  images?: Array<{ base64: string; mime: string }>;
+  notebooks?: string[]; // v0.4 Task 8 — 사용 가능한 노트북 목록. 미전달 시 빈 배열로 처리.
+}
+
+export interface GenerateOptions {
+  /** v0.3.1 Cut F — vision 전용 model 지정. null/미전달 시 기본 model 사용. */
+  visionModel?: string | null;
 }
 
 export interface HealthResult { ok: boolean; model?: string; reason?: string; }
 
 export interface InferenceProvider {
   readonly name: string;
-  generate(input: GenerateInput): Promise<AiResponse>;
+  generate(input: GenerateInput, opts?: GenerateOptions): Promise<AiResponse>;
   healthCheck(): Promise<HealthResult>;
   /** v0.2.3.1 — 외부에서 in-flight generate 강제 중단. ProviderHolder.replace 시 사용. */
   abort?: () => void;

src/main/ai/LocalOllamaProvider.ts

@@ -1,9 +1,41 @@
 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 { buildVisionPrompt } from './visionPrompt.js';
+import type { GenerateInput, GenerateOptions, HealthResult, InferenceProvider } from './InferenceProvider.js';
 import { DEFAULT_OLLAMA_ENDPOINT, DEFAULT_OLLAMA_MODEL } from '../../shared/constants.js';
 
+function classifyFetchError(e: unknown): 'network' | 'timeout' | 'dns' | 'other' {
+  const msg = ((e as Error)?.message ?? '').toLowerCase();
+  if (msg.includes('aborted') || msg.includes('timeout')) return 'timeout';
+  if (msg.includes('econnrefused') || msg.includes('econnreset')) return 'network';
+  if (msg.includes('enotfound') || msg.includes('eai_again')) return 'dns';
+  return 'other';
+}
+
+/**
+ * v0.3.11 — vision model 이 'format:json' constraint 를 부분적으로 따라 markdown 코드
+ * 펜스 / prose 가 섞인 응답을 반환할 때 fallback. 첫 '{' ~ 마지막 '}' substring 만
+ * 추출해서 JSON.parse 재시도.
+ *
+ * v0.3.14 — fail 시 throw 대신 `{}` 반환. schema 의 graceful coerce 가 빈 객체를
+ * placeholder title/summary 로 채움 → 사용자 데이터 손실 없이 노트 보관 (raw_text 그대로).
+ * 모델이 repetition loop 로 num_predict cap 도달해 JSON truncate 된 케이스에 robust.
+ * 원본 응답 snippet 은 console.warn 으로 로그 (디버그성).
+ */
+function parseJsonLoose(raw: string): unknown {
+  try { return JSON.parse(raw); } catch { /* fallback below */ }
+  const first = raw.indexOf('{');
+  const last = raw.lastIndexOf('}');
+  if (first >= 0 && last > first) {
+    const slice = raw.slice(first, last + 1);
+    try { return JSON.parse(slice); } catch { /* fall through */ }
+  }
+  // 빈 객체 반환 → schema coerce 로 placeholder 적용. 원본 일부는 stderr 에 남김.
+  console.warn(`[LocalOllamaProvider] unparseable response, falling back to {}: ${raw.slice(0, 200).replace(/\s+/g, ' ')}`);
+  return {};
+}
+
 export interface LocalOllamaOptions {
   endpoint?: string;
   model?: string;
@@ -30,30 +62,46 @@ export class LocalOllamaProvider implements InferenceProvider {
     this.name = `local-ollama/${this.model}`;
   }
 
-  async generate(input: GenerateInput): Promise<AiResponse> {
+  async generate(input: GenerateInput, opts?: GenerateOptions): Promise<AiResponse> {
+    const useVision = !!opts?.visionModel && (input.images?.length ?? 0) > 0;
+    const model = useVision ? opts!.visionModel! : this.model;
+    const prompt = useVision
+      ? buildVisionPrompt(input.text, input.todayKst, input.dueDateCandidates.map((c) => c.iso ?? c.matchedToken ?? ''), input.vocab ?? [])
+      : buildPrompt(input.text, input.todayKst, input.dueDateCandidates, input.vocab ?? [], input.notebooks ?? []);
+
+    // v0.3.13 — vision model 은 cold-start (모델 load + 이미지 encoding) 가 매우 느려
+    // 120s 기본 timeout 으로 첫 호출 fail 빈번. gemma4:26b (MoE 25B) 같은 대형 vision
+    // 모델은 첫 generate 가 60-180s 소요. 5분 (300s) 으로 확장.
+    const effectiveTimeout = useVision ? Math.max(this.timeoutMs, 300_000) : this.timeoutMs;
     this.abortController = new AbortController();
-    const timer = setTimeout(() => this.abortController?.abort(), this.timeoutMs);
+    const timer = setTimeout(() => this.abortController?.abort(), effectiveTimeout);
     try {
+      const body: Record<string, unknown> = {
+        model,
+        prompt,
+        format: 'json',
+        stream: false,
+        // v0.3.14 — repeat_penalty 추가. vision 모델 (특히 gemma 시리즈) 이 "기기기기..."
+        // 같은 repetition loop 에 빠져 num_predict cap 도달 → JSON truncate → unparseable.
+        // 1.15 는 Ollama 권장 범위 (1.0-1.3) 안쪽 conservative 값.
+        options: { temperature: this.temperature, num_predict: this.numPredict, repeat_penalty: 1.15 }
+      };
+      if (useVision) {
+        body.images = input.images!.map((i) => i.base64);
+      }
       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 }
-        }),
+        body: JSON.stringify(body),
         signal: this.abortController.signal
       });
       if (res.statusCode < 200 || res.statusCode >= 300) {
         throw new Error(`ollama http ${res.statusCode}`);
       }
-      const body = (await res.body.json()) as { response?: string };
-      if (!body.response) throw new Error('missing response field');
-      let parsed: unknown;
-      try { parsed = JSON.parse(body.response); }
-      catch (err) { throw new Error(`invalid json in response: ${String(err)}`); }
+      const responseBody = (await res.body.json()) as { response?: string };
+      if (!responseBody.response) throw new Error('missing response field');
+      // v0.3.11 — vision model 응답이 markdown fence / prose 섞인 경우 fallback 추출.
+      const parsed = parseJsonLoose(responseBody.response);
       return parseAiResponse(parsed);
     } finally {
       clearTimeout(timer);
@@ -108,7 +156,8 @@ export class LocalOllamaProvider implements InferenceProvider {
       return found ? { ok: true, model: this.model }
                    : { ok: false, reason: `${this.model} not installed` };
     } catch (err) {
-      return { ok: false, reason: `unreachable: ${(err as Error).message}` };
+      const cls = classifyFetchError(err);
+      return { ok: false, reason: `unreachable:${cls}` };
     }
   }
 }

src/main/ai/batchClassify.ts

@@ -0,0 +1,178 @@
+/**
+ * v0.4 T4 — default notebook 의 active 노트들을 단일 AI prompt 로 일괄 분류.
+ * N notes × 1 call 대신 한 번에 묶어 호출한다.
+ *
+ * Top N cap: 50 (prompt 크기 제한).
+ */
+
+import { z } from 'zod';
+import type { NoteRepository } from '../repository/NoteRepository.js';
+import type { NotebookRepository } from '../repository/NotebookRepository.js';
+
+export interface BatchClassifyResult {
+  assignments: Array<{ noteId: string; notebookId: string | null; notebookName: string | null }>;
+  skippedReason?: string;
+}
+
+export interface BatchClassifyDeps {
+  noteRepo: NoteRepository;
+  notebookRepo: NotebookRepository;
+  provider: { generateRaw: (prompt: string) => Promise<string> };
+}
+
+/** 한 번에 전달할 노트 최대 개수. prompt 크기 제한 대응. */
+const TOP_N_CAP = 50;
+
+// ---------------------------------------------------------------------------
+// Zod schema for AI response
+// ---------------------------------------------------------------------------
+
+const AssignmentSchema = z.object({
+  id: z.string(),
+  notebook: z.string().nullable()
+});
+
+const BatchResponseSchema = z.object({
+  assignments: z.array(AssignmentSchema)
+});
+
+// ---------------------------------------------------------------------------
+// Prompt builder
+// ---------------------------------------------------------------------------
+
+/**
+ * 한국어 batch 분류 prompt.
+ * 기존 buildPrompt 와 별도 함수 — 개별 메타데이터 생성이 아니라 batch 분류 전용.
+ */
+export function buildBatchClassifyPrompt(
+  notes: Array<{ id: string; snippet: string }>,
+  notebookNames: string[]
+): string {
+  const notebookList = notebookNames.join(', ');
+  const noteLines = notes
+    .map((n) => `- ${n.id}: "${n.snippet}"`)
+    .join('\n');
+
+  return `당신은 노트를 노트북으로 정리하는 AI 어시스턴트입니다. \
+아래 노트 목록과 사용 가능한 노트북 목록을 보고 각 노트가 어느 노트북에 가장 잘 맞는지 추천해주세요. \
+명확히 속하지 않으면 null 을 반환하세요.
+
+사용 가능한 노트북: ${notebookList}
+
+노트 목록 (id 와 짧은 제목/내용):
+${noteLines}
+
+규칙:
+- "assignments" 배열을 포함한 JSON 객체만 반환하세요.
+- 각 assignment 의 id 는 입력 id 와 정확히 일치해야 합니다.
+- notebook 은 위 사용 가능한 노트북 목록 중 하나 (대소문자 무관) 또는 null 이어야 합니다.
+- 새 노트북 이름을 만들지 마세요.
+- 마크다운 코드펜스나 설명 없이 JSON 만 반환하세요.
+
+예시:
+{"assignments": [{"id": "N1", "notebook": "회사"}, {"id": "N2", "notebook": null}]}`;
+}
+
+// ---------------------------------------------------------------------------
+// loose JSON extract (classifyStatus 와 동일한 패턴)
+// ---------------------------------------------------------------------------
+
+function parseJsonLoose(raw: string): unknown {
+  try { return JSON.parse(raw); } catch { /* fallback below */ }
+  const first = raw.indexOf('{');
+  const last = raw.lastIndexOf('}');
+  if (first >= 0 && last > first) {
+    const slice = raw.slice(first, last + 1);
+    try { return JSON.parse(slice); } catch { /* fall through */ }
+  }
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// Main service function
+// ---------------------------------------------------------------------------
+
+export async function batchClassifyDefault(deps: BatchClassifyDeps): Promise<BatchClassifyResult> {
+  const { noteRepo, notebookRepo, provider } = deps;
+
+  // 1. default notebook 조회
+  const defaultNb = notebookRepo.getDefault();
+  if (!defaultNb) {
+    return { assignments: [], skippedReason: 'no_default_notebook' };
+  }
+
+  // 2. 다른 notebook 목록 (default 제외) — 후보 notebook
+  const allNotebooks = notebookRepo.list();
+  const otherNotebooks = allNotebooks.filter((nb) => nb.id !== defaultNb.id);
+  if (otherNotebooks.length === 0) {
+    return { assignments: [], skippedReason: 'no_other_notebooks' };
+  }
+
+  // 3. default notebook 의 active 노트 조회 (cap 적용)
+  const notes = noteRepo.listByStatus('active', { notebookId: defaultNb.id, limit: TOP_N_CAP });
+  if (notes.length === 0) {
+    return { assignments: [], skippedReason: 'no_notes' };
+  }
+
+  // 4. 노트 snippet 생성 — aiTitle 우선, 없으면 rawText 앞 50자
+  const noteSnippets = notes.map((n) => ({
+    id: n.id,
+    snippet: (n.aiTitle ?? n.rawText).slice(0, 50)
+  }));
+
+  // 5. prompt 구성
+  const notebookNames = otherNotebooks.map((nb) => nb.name);
+  const prompt = buildBatchClassifyPrompt(noteSnippets, notebookNames);
+
+  // 6. AI 호출
+  let rawJson: string;
+  try {
+    rawJson = await provider.generateRaw(prompt);
+  } catch {
+    return { assignments: [], skippedReason: 'ai_error' };
+  }
+
+  // 7. JSON parse
+  const parsed = parseJsonLoose(rawJson);
+  if (parsed === null) {
+    return { assignments: [], skippedReason: 'parse_error' };
+  }
+
+  // 8. Zod validate
+  const validated = BatchResponseSchema.safeParse(parsed);
+  if (!validated.success) {
+    return { assignments: [], skippedReason: 'parse_error' };
+  }
+
+  // 9. 응답 매핑
+  const inputIds = new Set(notes.map((n) => n.id));
+  const assignments: BatchClassifyResult['assignments'] = [];
+
+  for (const item of validated.data.assignments) {
+    // input list 에 없는 id 는 skip
+    if (!inputIds.has(item.id)) continue;
+
+    if (item.notebook === null) {
+      assignments.push({ noteId: item.id, notebookId: null, notebookName: null });
+      continue;
+    }
+
+    // notebook name → NotebookRepository.findByName (case-insensitive)
+    const matched = notebookRepo.findByName(item.notebook);
+    if (!matched) {
+      // hallucinate 된 이름 — null 로 처리 (skip 대신 null 매핑으로 결과에는 포함)
+      assignments.push({ noteId: item.id, notebookId: null, notebookName: null });
+      continue;
+    }
+
+    // default notebook 으로 매핑된 경우는 null 처리 (이미 default 에 있음)
+    if (matched.id === defaultNb.id) {
+      assignments.push({ noteId: item.id, notebookId: null, notebookName: null });
+      continue;
+    }
+
+    assignments.push({ noteId: item.id, notebookId: matched.id, notebookName: matched.name });
+  }
+
+  return { assignments };
+}

src/main/ai/classifyStatus.ts

@@ -13,15 +13,16 @@ export interface ClassifyStatusOutput {
   rationale: string;
 }
 
-const VALID: readonly NoteStatus[] = ['completed', 'archived', 'trashed'];
+// v0.4 Task 16 — 'archived' 제거. completed / trashed 만 유효 추천값.
+// AI 응답이 'archived' 를 반환해도 VALID 에 없으므로 FALLBACK(completed) 로 coerce됨.
+const VALID: readonly NoteStatus[] = ['completed', 'trashed'];
 
 const PROMPT_TEMPLATE = `다음 메모를 분류하세요.
 가능한 status:
 - completed: 작업이 끝났고 더 이상 행동 불필요
-- archived: 장기 보관 — 회수 가능, 지금은 보지 않음
 - trashed: 불필요, 의미 없는 메모
 
-JSON 출력만 하세요: { "recommended": "completed|archived|trashed", "rationale": "<한 문장 한국어>" }
+JSON 출력만 하세요: { "recommended": "completed|trashed", "rationale": "<한 문장 한국어>" }
 
 메모 본문:
 {{rawText}}
@@ -32,17 +33,18 @@ JSON 출력만 하세요: { "recommended": "completed|archived|trashed", "ration
 사용자 이동 사유:
 {{reason}}`;
 
+// v0.4 Task 16 — fallback 을 'completed' 로 변경 ('archived' 제거).
 const FALLBACK: ClassifyStatusOutput = {
-  recommended: 'archived',
-  rationale: '판단 실패 — 안전하게 보관 추천'
+  recommended: 'completed',
+  rationale: '판단 실패 — 완료 처리 추천'
 };
 
 /**
  * v0.2.9 Cut B Task 9 — AI 자동 분류 (status 추천).
  *
  * provider.generateRaw 가 있으면 raw JSON 응답 사용, 없으면 generate() 재사용 시도
- * (그 경우 응답 형태 불일치로 보통 fallback). 에러/parse 실패 시 'archived' 안전 default
- * (사용자 데이터 보존 우선).
+ * (그 경우 응답 형태 불일치로 보통 fallback). 에러/parse 실패 시 'completed' fallback
+ * (v0.4 Task 16 — 'archived' 제거, 안전 default 를 completed 로 변경).
  */
 export async function classifyStatus(
   input: ClassifyStatusInput

src/main/ai/prompt.ts

@@ -6,7 +6,8 @@ export function buildPrompt(
   rawText: string,
   todayKst: string,
   candidates: ParseResult[] = [],
-  vocab: string[] = []
+  vocab: string[] = [],
+  notebooks: string[] = []
 ): string {
   const candidateBlock = candidates.length > 0
     ? `\nDate candidates extracted by a Korean rule parser (these are HINTS — you decide which is correct, or pick null):
@@ -17,11 +18,19 @@ ${candidates.map((c, i) => `  ${i + 1}. ${c.iso ?? '(ambiguous)'} — matched to
     ? `\nExisting vocabulary tags (most-used first): ${vocab.join(', ')}\nPrefer reusing a vocabulary tag when the meaning matches; create new tags only when the meaning is genuinely new.\n`
     : '';
 
-  // candidateBlock & vocabBlock are self-delimited with leading/trailing \n
+  const notebookBlock = notebooks.length > 0
+    ? `\n사용 가능한 노트북: ${notebooks.join(', ')}\n이 노트가 위 노트북 중 하나에 명확히 속하면 "notebook_match" 에 그 이름을, 그렇지 않으면 null 을 반환. 기존 목록 안에서만 선택 — 새 이름 만들지 말 것.\n`
+    : '';
+
+  const notebookKeySpec = notebooks.length > 0
+    ? `\n- "notebook_match": 위 사용 가능한 노트북 목록 중 하나의 이름 또는 null`
+    : '';
+
+  // candidateBlock & vocabBlock & notebookBlock are self-delimited with leading/trailing \n
   return `You organize raw personal notes into structured metadata.
 
 Today's date in Korea Standard Time (KST): ${todayKst}
-${candidateBlock}${vocabBlock}
+${candidateBlock}${vocabBlock}${notebookBlock}
 Input note (raw text, may be fragmented, any language):
 ---
 ${rawText}
@@ -31,7 +40,7 @@ Return a JSON object with EXACTLY these keys:
 - "title": concise title in KOREAN (max 60 chars)
 - "summary": 3-line summary in KOREAN. Each line max 120 chars. Lines separated by "\\n".
 - "tags": array of 0 to 3 tags in lowercase kebab-case (English letters and digits only, e.g., "api-timeout", "weekly-retro"). Empty array if no clear tags.
-- "due_date": ISO YYYY-MM-DD if you are CONFIDENT about a deadline, else null. Consider rule candidates above as hints but use your own judgment — if multiple ambiguous candidates ("내일 모레", "이번 주 다음 주"), prefer null. If the user wrote "오늘 PR 리뷰" with no deadline implication, return null.
+- "due_date": ISO YYYY-MM-DD if you are CONFIDENT about a deadline, else null. Consider rule candidates above as hints but use your own judgment — if multiple ambiguous candidates ("내일 모레", "이번 주 다음 주"), prefer null. If the user wrote "오늘 PR 리뷰" with no deadline implication, return null.${notebookKeySpec}
 
 Rules:
 - title and summary MUST be written in Korean regardless of input language.

src/main/ai/schema.ts

@@ -8,7 +8,8 @@ const RawResponseSchema = z.object({
   title: z.string().trim().min(1).max(200),
   summary: z.string().min(1),
   tags: z.array(z.string()).default([]),
-  due_date: z.string().regex(ISO_DATE_REGEX).nullable().optional()
+  due_date: z.string().regex(ISO_DATE_REGEX).nullable().optional(),
+  notebook_match: z.string().nullable().optional()
 });
 
 export interface AiResponse {
@@ -16,6 +17,7 @@ export interface AiResponse {
   summary: string;
   tags: string[];
   dueDate: string | null;
+  notebookMatch: string | null;
 }
 
 function normalizeSummary(raw: string): string {
@@ -39,15 +41,37 @@ function validateDueDate(d: string | null | undefined): string | null {
   return d;
 }
 
-export function parseAiResponse(raw: unknown): AiResponse {
-  const parsed = RawResponseSchema.parse(raw);
-  if (!KOREAN_REGEX.test(parsed.title)) {
-    throw new Error('title must contain Korean characters');
+/**
+ * vision 모델 (gemma4:26b 등) 이 본문 빈 케이스에 title/summary null 반환하는 케이스
+ * 대응. null → placeholder 한국어 문자열로 coerce 후 schema 통과. 빈 string / empty regex
+ * dueDate 도 null 로 normalize. raw_text 는 호출자가 보존하므로 사용자 데이터 손실 없음.
+ */
+function coerceNullable(raw: unknown): unknown {
+  if (typeof raw !== 'object' || raw === null) return raw;
+  const obj = { ...(raw as Record<string, unknown>) };
+  if (obj.title === null || obj.title === undefined || obj.title === '') obj.title = '(첨부 메모)';
+  if (obj.summary === null || obj.summary === undefined || obj.summary === '') obj.summary = '내용을 자동으로 정리하지 못했습니다.';
+  // due_date 의 빈 string / regex mismatch 도 null 로 강제 (schema 가 거부하지 않게).
+  if (obj.due_date === '' || (typeof obj.due_date === 'string' && !ISO_DATE_REGEX.test(obj.due_date))) {
+    obj.due_date = null;
   }
+  // tags 가 null 이면 빈 배열로.
+  if (obj.tags === null || obj.tags === undefined) obj.tags = [];
+  return obj;
+}
+
+export function parseAiResponse(raw: unknown): AiResponse {
+  const coerced = coerceNullable(raw);
+  const parsed = RawResponseSchema.parse(coerced);
+  // title 이 한국어 0 자면 fallback placeholder 적용 (영어 title 도 fail 안 함).
+  // placeholder 는 한국어 포함이라 자기 자신 통과.
+  const titleHasKorean = KOREAN_REGEX.test(parsed.title);
+  const finalTitle = titleHasKorean ? parsed.title : '(첨부 메모)';
   return {
-    title: parsed.title.slice(0, 60),
+    title: finalTitle.slice(0, 60),
     summary: normalizeSummary(parsed.summary),
     tags: parsed.tags.filter((t) => KEBAB_REGEX.test(t)).slice(0, 3),
-    dueDate: validateDueDate(parsed.due_date)
+    dueDate: validateDueDate(parsed.due_date),
+    notebookMatch: parsed.notebook_match ?? null
   };
 }

src/main/ai/visionPrompt.ts

@@ -0,0 +1,37 @@
+export function buildVisionPrompt(
+  text: string,
+  todayKst: string,
+  dueCandidates: string[],
+  vocab: string[]
+): string {
+  // v0.3.14 — 본문 빈 케이스에 one-shot 예시 추가. gemma4:26b 등이 본문 없이
+  // 이미지만 받으면 null 반환하는 한계 우회. 예시 입력/출력 구조 따라가도록 유도.
+  const bodySection = text
+    ? `메모 본문:\n${text}\n\n첨부 이미지도 함께 분석해 요약에 반영하세요.`
+    : `본문이 없습니다. 첨부 이미지의 내용 (텍스트/사람/장면/문서 등) 만으로 한국어 title 과 summary 를 작성하세요. null 반환 절대 금지.
+
+예시 (이미지: 갈색 강아지가 잔디 위에 앉은 사진):
+{"title":"잔디 위 강아지","summary":"갈색 강아지가 잔디 위에 앉아 있다.\\n배경에 나무가 보인다.\\n날씨가 맑다.","tags":["pet"],"due_date":null}
+
+예시 (이미지: 회의실 화이트보드 사진):
+{"title":"회의실 화이트보드","summary":"화이트보드에 일정과 안건이 적혀 있다.\\n프로젝트 이름이 보인다.\\n다이어그램이 그려져 있다.","tags":["meeting"],"due_date":null}
+
+이제 첨부된 실제 이미지를 보고 같은 형식으로 작성하세요.`;
+
+  return `다음 메모를 한국어로 분석해 JSON 으로 정리하세요.
+
+${bodySection}
+
+규칙 (위반 시 재시도):
+- "title": 한국어 문자열 필수, null 금지. 60자 이내. 영어 단독 금지.
+- "summary": 한국어 문자열 필수, null 금지. 3줄. 이미지 시각 정보 (텍스트/사람/장면) 포함.
+- "tags": 영문 kebab-case 배열 (예: ["meeting-notes"]), 최대 3개. 한국어 태그 금지. 없으면 [].
+- "due_date": ISO YYYY-MM-DD 또는 null. 빈 문자열 금지.
+
+오직 JSON 객체 하나만 출력. markdown 코드 펜스 (\`\`\`) / 설명 prose 금지.
+출력 형식: {"title":"...","summary":"...","tags":[],"due_date":null}
+
+오늘: ${todayKst}
+가능한 due 후보: ${dueCandidates.join(', ')}
+빈출 태그: ${vocab.slice(0, 20).join(', ')}`;
+}

src/main/db/migrations/index.ts

@@ -5,8 +5,11 @@ import * as m003 from './m003_soft_delete.js';
 import * as m004 from './m004_status.js';
 import * as m005 from './m005_ai_disabled.js';
 import * as m006 from './m006_revisions.js';
+import * as m007 from './m007_fts.js';
+import * as m008 from './m008_notebooks.js';
+import * as m009 from './m009_notebook_order.js';
 
-const migrations = [m001, m002, m003, m004, m005, m006];
+const migrations = [m001, m002, m003, m004, m005, m006, m007, m008, m009];
 
 export function latestVersion(): number {
   return migrations[migrations.length - 1]!.version;

src/main/db/migrations/m007_fts.ts

@@ -0,0 +1,48 @@
+// v7: notes_fts FTS5 virtual table + trigger 3개 + 기존 notes (status != 'trashed') backfill.
+// raw_text/ai_title/ai_summary 는 trigger 자동 sync. tags 는 note_tags JOIN 결과를
+// NoteRepository 의 명시 헬퍼 (rebuildFtsTagsForNote) 로 갱신 — Cut D 의 single write path.
+import type Database from 'better-sqlite3';
+
+export const version = 7;
+
+export function up(db: Database.Database): void {
+  db.exec(`
+    CREATE VIRTUAL TABLE notes_fts USING fts5(
+      note_id UNINDEXED,
+      raw_text,
+      ai_title,
+      ai_summary,
+      tags,
+      tokenize='unicode61'
+    );
+
+    CREATE TRIGGER notes_fts_ai AFTER INSERT ON notes BEGIN
+      INSERT INTO notes_fts (note_id, raw_text, ai_title, ai_summary, tags)
+        VALUES (NEW.id, NEW.raw_text, COALESCE(NEW.ai_title, ''), COALESCE(NEW.ai_summary, ''), '');
+    END;
+
+    CREATE TRIGGER notes_fts_ad AFTER DELETE ON notes BEGIN
+      DELETE FROM notes_fts WHERE note_id = OLD.id;
+    END;
+
+    CREATE TRIGGER notes_fts_au AFTER UPDATE ON notes BEGIN
+      UPDATE notes_fts
+         SET raw_text   = NEW.raw_text,
+             ai_title   = COALESCE(NEW.ai_title, ''),
+             ai_summary = COALESCE(NEW.ai_summary, '')
+       WHERE note_id = NEW.id;
+    END;
+
+    INSERT INTO notes_fts (note_id, raw_text, ai_title, ai_summary, tags)
+      SELECT
+        n.id,
+        n.raw_text,
+        COALESCE(n.ai_title, ''),
+        COALESCE(n.ai_summary, ''),
+        COALESCE((SELECT GROUP_CONCAT(t.name, ' ')
+                    FROM note_tags nt JOIN tags t ON t.id = nt.tag_id
+                   WHERE nt.note_id = n.id), '')
+      FROM notes n
+      WHERE n.status != 'trashed';
+  `);
+}

src/main/db/migrations/m008_notebooks.ts

@@ -0,0 +1,37 @@
+// v8: notebooks 테이블 + notes.notebook_id (FK) + archived → completed 정리.
+// CHECK 제약 없는 status 컬럼이라 SQL 변경은 데이터 정리만, enum 단속은 TypeScript 측에서.
+import type Database from 'better-sqlite3';
+import { v7 as uuidv7 } from 'uuid';
+
+export const version = 8;
+
+const DEFAULT_NOTEBOOK_NAME = '기본';
+
+export function up(db: Database.Database): void {
+  const now = new Date().toISOString();
+  const defaultId = uuidv7();
+
+  db.exec(`
+    CREATE TABLE notebooks (
+      id         TEXT PRIMARY KEY,
+      name       TEXT NOT NULL,
+      color      TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+    CREATE UNIQUE INDEX idx_notebooks_name ON notebooks(name COLLATE NOCASE);
+
+    ALTER TABLE notes ADD COLUMN notebook_id TEXT
+      REFERENCES notebooks(id) ON DELETE RESTRICT;
+    CREATE INDEX idx_notes_notebook_id ON notes(notebook_id);
+  `);
+
+  db.prepare(
+    `INSERT INTO notebooks (id, name, created_at, updated_at) VALUES (?, ?, ?, ?)`
+  ).run(defaultId, DEFAULT_NOTEBOOK_NAME, now, now);
+
+  db.prepare(`UPDATE notes SET notebook_id = ? WHERE notebook_id IS NULL`).run(defaultId);
+
+  // archived 잔류 (dogfood 0건 확인됐지만 defensive) → completed 로 통합.
+  db.prepare(`UPDATE notes SET status='completed' WHERE status='archived'`).run();
+}

src/main/db/migrations/m009_notebook_order.ts

@@ -0,0 +1,17 @@
+// v9: notebooks.sort_order 컬럼 추가 + 기존 notebooks 를 created_at 순서로 backfill.
+// NotebookList 사이드바 의 순서 변경 (T2/T3) 의 schema 기반.
+import type Database from 'better-sqlite3';
+
+export const version = 9;
+
+export function up(db: Database.Database): void {
+  db.exec(`
+    ALTER TABLE notebooks ADD COLUMN sort_order INTEGER NOT NULL DEFAULT 0;
+    CREATE INDEX idx_notebooks_sort_order ON notebooks(sort_order, created_at);
+  `);
+
+  // 기존 notebooks 를 created_at 순서로 0,1,2,... 채움
+  const rows = db.prepare(`SELECT id FROM notebooks ORDER BY created_at ASC, id ASC`).all() as Array<{ id: string }>;
+  const update = db.prepare(`UPDATE notebooks SET sort_order = ? WHERE id = ?`);
+  rows.forEach((r, idx) => update.run(idx, r.id));
+}

src/main/index.ts

@@ -17,9 +17,12 @@ 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 { refreshVisionCache } from './services/VisionDetect.js';
 import { registerCaptureApi } from './ipc/captureApi.js';
 import { registerInboxApi, pushNoteUpdated, pushOllamaStatus } from './ipc/inboxApi.js';
 import { registerSettingsApi, navigateInbox } from './ipc/settingsApi.js';
+import { NotebookRepository } from './repository/NotebookRepository.js';
+import { registerNotebookApi } from './ipc/notebookApi.js';
 import { createInboxWindow, getInboxWindow } from './windows/inboxWindow.js';
 import {
   createQuickCaptureWindow, showQuickCapture, getQuickCaptureWindow
@@ -30,6 +33,7 @@ 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 { SyncTimer } from './services/SyncTimer.js';
 import { TelemetryService } from './services/TelemetryService.js';
 import { SettingsService } from './services/SettingsService.js';
 import { collectAutostartState } from './services/AutostartDiagnostic.js';
@@ -99,6 +103,8 @@ app.whenReady().then(async () => {
   }
   const db = openDb(paths.dbFile);
   const repo = new NoteRepository(db);
+  const notebookRepo = new NotebookRepository(db);
+  registerNotebookApi({ repo: notebookRepo });
   const store = new MediaStore(paths.profileDir);
   const continuity = new ContinuityService(db);
   const intent = new IntentService(repo);
@@ -121,6 +127,11 @@ app.whenReady().then(async () => {
 
   const provider = new LocalOllamaProvider({ endpoint: resolvedEndpoint, model: resolvedModel });
   const providerHolder = new ProviderHolder(provider);
+
+  // v0.3.1 Cut F — app launch 시 vision capability cache 갱신 (fire-and-forget).
+  // 실패 silent (cache 유지). 사용자가 설정 페이지에서 "다시 감지" manual trigger 가능.
+  void refreshVisionCache({ settings: settingsSvc, endpoint: resolvedEndpoint }).catch(() => {});
+
   const health = new HealthChecker(providerHolder, {
     // v0.2.9 Cut B Task 14 — AI 비활성 시 health polling skip (Ollama 미설치 환경 무영향).
     isAiEnabled: () => settingsSvc.isAiEnabled(),
@@ -148,7 +159,12 @@ app.whenReady().then(async () => {
       refreshTray({ todayCount: repo.countToday() });
     },
     logger,
-    telemetry
+    telemetry,
+    // v0.3.1 Cut F — vision 지원
+    settings: settingsSvc,
+    mediaStore: store,
+    // v0.4 — notebook_match 자동 이동
+    notebookRepo: notebookRepo
   });
 
   const notify = new NotificationService({
@@ -171,7 +187,9 @@ app.whenReady().then(async () => {
     getInboxWindow, settings: settingsSvc, providerHolder,
     paths: { profileDir: paths.profileDir },
     // v0.2.9 Cut B Task 16 — disabled 메모 일괄 재투입 시 in-memory queue 갱신.
-    enqueue: (id) => worker.enqueue(id)
+    enqueue: (id) => worker.enqueue(id),
+    // v0.4 Task 11 — promotion candidates IPC 가 default notebook 식별에 사용.
+    notebookRepo
   });
   // registerSettingsApi 는 backup / exportSvc / importSvc / syncSvc / telemetry 가
   // 생성된 뒤에 호출 (Task 10) — 아래 BackupService/ExportService/... 초기화 직후로 이동.
@@ -183,9 +201,10 @@ app.whenReady().then(async () => {
   });
   if (!reg.ok) logger.warn('hotkey.register.failed', { reason: reg.reason });
 
-  if (!startedHidden) {
-    createInboxWindow();
-  }
+  // macOS LoginItems autostart 시 startedHidden=true 로 spawn — 그대로 두면 quickCapture
+  // (NSPanel) 만 떠 있어 dock running indicator 미표출. inboxWindow 를 hidden 상태로
+  // 미리 create 하면 NSApp register → 점 표출 + 사용자가 dock 아이콘 확인으로 앱 살아있음 인지.
+  createInboxWindow({ visible: !startedHidden });
   createQuickCaptureWindow();
   await worker.loadFromDb();
 
@@ -196,7 +215,8 @@ app.whenReady().then(async () => {
 
   const exportSvc = new ExportService(repo, store);
   const importSvc = new ImportService(repo, store);
-  const syncSvc = new SyncService(paths.profileDir, exportSvc);
+  const syncSvc = new SyncService(paths.profileDir, exportSvc, importSvc);
+  const syncTimer = new SyncTimer(syncSvc, settingsSvc);
 
   const backup = new BackupService(db, join(paths.profileDir, 'backups'));
   void backup.runDaily()
@@ -206,14 +226,18 @@ app.whenReady().then(async () => {
   // v0.2.7 Task 10 — 설정 페이지 IPC (autostart + backup/export/import/sync/telemetry).
   // backup / exportSvc / importSvc / syncSvc / telemetry 가 모두 준비된 뒤 등록.
   registerSettingsApi({
-    backup, exportSvc, importSvc, syncSvc, telemetry, settings: settingsSvc, getInboxWindow
+    backup, exportSvc, importSvc, syncSvc, telemetry, settings: settingsSvc, getInboxWindow,
+    syncTimer
   });
 
+  void syncTimer.start();
+
   let backupOnQuitDone = false;
   let trayInterval: NodeJS.Timeout | null = null;
   app.on('before-quit', (e) => {
     // 모든 cleanup 한 곳에 통합 — sync (idempotent) → async backup chain.
     health.stop();
+    syncTimer.stop();
     if (trayInterval !== null) {
       clearInterval(trayInterval);
       trayInterval = null;

src/main/ipc/inboxApi.ts

@@ -3,6 +3,7 @@ import type { BrowserWindow } from 'electron';
 const { ipcMain, dialog, shell } = electron;
 import { join, normalize, sep } from 'node:path';
 import type { NoteRepository } from '../repository/NoteRepository.js';
+import type { NotebookRepository } from '../repository/NotebookRepository.js';
 import type { ContinuityService } from '../services/ContinuityService.js';
 import type { CaptureService } from '../services/CaptureService.js';
 import type { HealthChecker } from '../services/HealthChecker.js';
@@ -11,6 +12,7 @@ import type { Note, NoteStatus } from '@shared/types';
 import type { HealthResult } from '../ai/InferenceProvider.js';
 import { LocalOllamaProvider } from '../ai/LocalOllamaProvider.js';
 import { classifyStatus } from '../ai/classifyStatus.js';
+import { batchClassifyDefault } from '../ai/batchClassify.js';
 import type { SettingsService } from '../services/SettingsService.js';
 import type { ProviderHolder } from '../ai/ProviderHolder.js';
 
@@ -29,10 +31,13 @@ export interface InboxIpcDeps {
   // 미주입 시 fire-and-forget skip (다음 launch 의 loadFromDb 가 처리). 본 hook 은
   // AiWorker 인스턴스 직접 주입을 피해 IPC 모듈이 worker import 를 갖지 않도록 분리.
   enqueue?: (noteId: string) => Promise<void>;
+  // v0.4 Task 11 — promotion candidates IPC 가 default notebook 식별에 사용.
+  // 미주입 시 list-promotion-candidates 는 빈 배열 반환 (graceful fallback).
+  notebookRepo?: NotebookRepository;
 }
 
 export function registerInboxApi(deps: InboxIpcDeps): void {
-  ipcMain.handle('inbox:list', (_e, opts: { limit: number; cursor?: string }) =>
+  ipcMain.handle('inbox:list', (_e, opts: { limit: number; cursor?: string; notebookId?: string }) =>
     deps.repo.list(opts)
   );
 
@@ -150,11 +155,30 @@ export function registerInboxApi(deps: InboxIpcDeps): void {
   ipcMain.handle('inbox:retryAllFailed', async () => deps.capture.retryAllFailed());
   ipcMain.handle('inbox:failedCount', () => deps.repo.countFailed());
 
+  // v0.3.9 — per-note retry/cancel. failed/pending 사용자 막힘 해소 path.
+  // status 변경 후 pushNoteUpdated 로 renderer counts/list 자동 sync.
+  ipcMain.handle('inbox:retry-one-failed', async (_e, id: string) => {
+    const r = await deps.capture.retryOneFailed(id);
+    if (r.ok) {
+      const updated = deps.repo.findById(id);
+      if (updated !== null) pushNoteUpdated(deps.getInboxWindow, updated);
+    }
+    return r;
+  });
+  ipcMain.handle('inbox:cancel-pending', (_e, id: string) => {
+    const r = deps.capture.cancelPending(id);
+    if (r.ok) {
+      const updated = deps.repo.findById(id);
+      if (updated !== null) pushNoteUpdated(deps.getInboxWindow, updated);
+    }
+    return r;
+  });
+
   ipcMain.handle('inbox:listRecallCandidate', () => deps.capture.listRecallCandidate());
   ipcMain.handle('inbox:markRecallOpened', (_e, id: string) => deps.capture.markRecallOpened(id));
   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.on('inbox:emitRecallShown', (_e, id: string) => { void deps.capture.emitRecallShown(id); });
+  ipcMain.on('inbox:emitRecallSnoozed', (_e, id: string) => { void deps.capture.emitRecallSnoozed(id); });
 
   ipcMain.handle('inbox:loadOllamaSettings', async () => {
     const s = await deps.settings.load();
@@ -178,47 +202,55 @@ export function registerInboxApi(deps: InboxIpcDeps): void {
   });
 
   // v0.2.9 Cut B Task 4 — status 별 노트 목록.
+  // v0.4 — notebookId 옵션 추가. archived 는 v0.4 에서 제거된 status — graceful fallback.
   ipcMain.handle(
     'inbox:list-by-status',
-    (_e, status: NoteStatus, opts: { limit?: number } = {}) => {
-      const VALID: readonly NoteStatus[] = ['active', 'completed', 'archived', 'trashed'];
+    (_e, status: NoteStatus, opts: { limit?: number; notebookId?: string } = {}) => {
+      // archived 는 v0.4 에서 completed 로 통합 — 빈 결과로 graceful fallback (caller 안전).
+      if ((status as string) === 'archived') return [] as Note[];
+      const VALID: readonly NoteStatus[] = ['active', 'completed', 'trashed'];
       if (!VALID.includes(status)) return [] as Note[];
       return deps.repo.listByStatus(status, opts);
     }
   );
 
-  // v0.2.9 Cut B Task 4 — 4 status counts (헤더 4탭 badge).
-  ipcMain.handle('inbox:counts-by-status', () => ({
-    active: deps.repo.countByStatus('active'),
-    completed: deps.repo.countByStatus('completed'),
-    archived: deps.repo.countByStatus('archived'),
-    trashed: deps.repo.countByStatus('trashed')
+  // v0.2.9 Cut B Task 4 — status counts (헤더 탭 badge).
+  // v0.4 — archived 제거 (3 status 만 반환). notebookId 옵션 추가.
+  ipcMain.handle('inbox:counts-by-status', (_e, opts: { notebookId?: string } = {}) => ({
+    active: deps.repo.countByStatus('active', opts),
+    completed: deps.repo.countByStatus('completed', opts),
+    trashed: deps.repo.countByStatus('trashed', opts)
   }));
 
   // v0.2.9 Cut B Task 8 — status 4분기 직접 전이 (사유 포함).
   // Modal 의 "완료/보관/휴지통" 버튼 path. backward compat 동기화는
   // NoteRepository.setStatus 내부에서 처리 (deleted_at sync).
+  // v0.3.8 — setStatus 도 pushNoteUpdated emit. 이전엔 emit 안 해서 renderer 의 store
+  // (counts/search/list) 가 stale 되어 NoteCard 호출처마다 명시적 refreshMeta 호출이
+  // 필요했음. push 화 시 onNoteUpdated 콜백 1개 path 로 일관 갱신.
   ipcMain.handle(
     'inbox:set-status',
     async (_e, id: string, status: NoteStatus, reason: string | null) => {
-      const VALID: readonly NoteStatus[] = ['active', 'completed', 'archived', 'trashed'];
+      const VALID: readonly NoteStatus[] = ['active', 'completed', 'trashed'];
       if (!VALID.includes(status)) {
         return { ok: false as const, reason: 'invalid status' as const };
       }
       deps.repo.setStatus(id, status, reason);
+      const updated = deps.repo.findById(id);
+      if (updated !== null) pushNoteUpdated(deps.getInboxWindow, updated);
       return { ok: true as const };
     }
   );
 
   // v0.2.9 Cut B Task 9 — AI 자동 분류 (status 추천).
-  // Ollama provider.generateRaw 호출 + JSON 응답 파싱. 에러/실패 시 archived fallback
-  // (사용자 데이터 보존 우선). 자세한 prompt + parse 로직은 src/main/ai/classifyStatus.ts.
+  // Ollama provider.generateRaw 호출 + JSON 응답 파싱. 에러/실패 시 completed fallback
+  // (v0.4 Task 16 — 'archived' 제거). 자세한 prompt + parse 로직은 src/main/ai/classifyStatus.ts.
   ipcMain.handle('ai:classify-status', async (_e, id: string, reason: string) => {
     const note = deps.repo.findById(id);
     if (note === null) {
       return {
-        recommended: 'archived' as const,
-        rationale: '메모를 찾을 수 없음 — 안전하게 보관 추천'
+        recommended: 'completed' as const,
+        rationale: '메모를 찾을 수 없음 — 완료 처리 추천'
       };
     }
     const provider = deps.providerHolder.get();
@@ -230,6 +262,20 @@ export function registerInboxApi(deps: InboxIpcDeps): void {
     });
   });
 
+  // v0.4 T4 — AI batch classify: default notebook 노트 일괄 fit 매칭 (단일 prompt).
+  ipcMain.handle('inbox:batch-classify-default', async () => {
+    if (!deps.notebookRepo) return { assignments: [], skippedReason: 'no_notebook_repo' };
+    const provider = deps.providerHolder.get();
+    if (typeof provider.generateRaw !== 'function') {
+      return { assignments: [], skippedReason: 'no_generate_raw' };
+    }
+    return batchClassifyDefault({
+      noteRepo: deps.repo,
+      notebookRepo: deps.notebookRepo,
+      provider: provider as { generateRaw: (prompt: string) => Promise<string> }
+    });
+  });
+
   // v0.2.9 Cut B Task 16 — disabled 메모 (ai_enabled OFF 시기 캡처) 일괄 재투입.
   // OFF→ON 전환 후 사용자가 "지금 모두 처리" 버튼 클릭 path. repo.requeueDisabled 가
   // ai_status='pending' + pending_jobs row 보장, worker.enqueue 가 in-memory queue 갱신.
@@ -253,6 +299,30 @@ export function registerInboxApi(deps: InboxIpcDeps): void {
 
   ipcMain.handle('inbox:get-disabled-count', () => deps.repo.countByAiStatus('disabled'));
 
+  // v0.4 Task 11 — promotion candidates + dismissed/snoozed 영속화.
+  ipcMain.handle('inbox:list-promotion-candidates', () => {
+    if (!deps.notebookRepo) return [];
+    const defaultNb = deps.notebookRepo.getDefault();
+    if (!defaultNb) return [];
+    return deps.repo.findPromotionCandidates(defaultNb.id);
+  });
+
+  ipcMain.handle('inbox:get-promotion-dismissed-tags', () =>
+    deps.settings.getPromotionDismissedTags()
+  );
+
+  ipcMain.handle('inbox:add-promotion-dismissed-tag', (_e, tag: string) =>
+    deps.settings.addPromotionDismissedTag(tag)
+  );
+
+  ipcMain.handle('inbox:get-promotion-snoozed-until', () =>
+    deps.settings.getPromotionSnoozeUntil()
+  );
+
+  ipcMain.handle('inbox:set-promotion-snoozed-until', (_e, ms: number) =>
+    deps.settings.setPromotionSnoozeUntil(ms)
+  );
+
   ipcMain.handle('inbox:saveOllamaSettings', async (_e, value: { endpoint: string; model: string }) => {
     // 검증: 새 인스턴스로 healthCheck
     const trial = new LocalOllamaProvider({ endpoint: value.endpoint, model: value.model });
@@ -279,6 +349,7 @@ export function registerInboxApi(deps: InboxIpcDeps): void {
       return { ok: false as const, reason: 'empty' as const };
     }
     deps.repo.updateRawText(id, newText);
+    await reprocessAi(deps, id);
     return { ok: true as const };
   });
 
@@ -287,11 +358,33 @@ export function registerInboxApi(deps: InboxIpcDeps): void {
   ipcMain.handle('inbox:restore-revision', async (_e, id: string, revId: number) => {
     try {
       deps.repo.restoreRevision(id, revId);
+      await reprocessAi(deps, id);
       return { ok: true as const };
     } catch (e) {
       return { ok: false as const, reason: (e as Error).message };
     }
   });
+
+  // v0.2.11 Cut D — FTS5 검색 + 회고 aggregate.
+  // v0.4 — notebookId 옵션 추가.
+  ipcMain.handle(
+    'inbox:search',
+    (_e, query: string, opts: { limit?: number; status?: NoteStatus; notebookId?: string } = {}) =>
+      deps.repo.search(query, opts)
+  );
+
+  ipcMain.handle('inbox:review-aggregate', (_e, period: 'daily' | 'weekly' | 'monthly') => {
+    const VALID = ['daily', 'weekly', 'monthly'] as const;
+    if (!(VALID as readonly string[]).includes(period)) {
+      return {
+        totalCount: 0,
+        recentNotes: [],
+        tagCounts: [],
+        dueProgress: { total: 0, passed: 0, pending: 0 }
+      };
+    }
+    return deps.repo.reviewAggregate(period);
+  });
 }
 
 export function pushNoteUpdated(getWin: () => BrowserWindow | null, note: Note): void {
@@ -300,6 +393,19 @@ export function pushNoteUpdated(getWin: () => BrowserWindow | null, note: Note):
   w.webContents.send('note:updated', note);
 }
 
+/**
+ * 원문 변경 후 AI 재처리 트리거. ai_status='pending' 으로 reset + pending_jobs 재투입 +
+ * worker enqueue + renderer push. disabled 노트는 사용자 명시 비활성화 의도 존중하여 skip.
+ */
+async function reprocessAi(deps: InboxIpcDeps, id: string): Promise<void> {
+  const now = new Date().toISOString();
+  const r = deps.repo.markAiPendingForReprocess(id, now);
+  if (!r.ok) return;
+  if (deps.enqueue) await deps.enqueue(id);
+  const updated = deps.repo.findById(id);
+  if (updated !== null) pushNoteUpdated(deps.getInboxWindow, updated);
+}
+
 export function pushOllamaStatus(getWin: () => BrowserWindow | null, status: HealthResult): void {
   const w = getWin();
   if (!w || w.isDestroyed()) return;

src/main/ipc/notebookApi.ts

@@ -0,0 +1,53 @@
+import electron from 'electron';
+const { ipcMain } = electron;
+import type { NotebookRepository } from '../repository/NotebookRepository.js';
+
+export interface NotebookIpcDeps {
+  repo: NotebookRepository;
+}
+
+export function registerNotebookApi(deps: NotebookIpcDeps): void {
+  ipcMain.handle('notebook:list', () => deps.repo.list());
+
+  ipcMain.handle('notebook:create', (_e, input: { name: string; color?: string }) => {
+    if (!input.name || input.name.trim().length === 0) {
+      return { ok: false as const, reason: 'empty_name' };
+    }
+    try {
+      const nb = deps.repo.create({ name: input.name.trim(), color: input.color ?? null });
+      return { ok: true as const, notebook: nb };
+    } catch (e) {
+      const msg = (e as Error).message;
+      if (msg.includes('UNIQUE')) return { ok: false as const, reason: 'duplicate_name' };
+      return { ok: false as const, reason: msg };
+    }
+  });
+
+  ipcMain.handle('notebook:rename', (_e, id: string, name: string) => {
+    if (!name || name.trim().length === 0) {
+      return { ok: false as const, reason: 'empty_name' };
+    }
+    try {
+      deps.repo.rename(id, name.trim());
+      return { ok: true as const };
+    } catch (e) {
+      const msg = (e as Error).message;
+      if (msg.includes('UNIQUE')) return { ok: false as const, reason: 'duplicate_name' };
+      return { ok: false as const, reason: msg };
+    }
+  });
+
+  ipcMain.handle('notebook:set-color', (_e, id: string, color: string | null) => {
+    deps.repo.setColor(id, color);
+    return { ok: true as const };
+  });
+
+  ipcMain.handle('notebook:delete', (_e, id: string) => deps.repo.delete(id));
+
+  ipcMain.handle('notebook:move-note', (_e, noteId: string, notebookId: string) => {
+    deps.repo.moveNote(noteId, notebookId);
+    return { ok: true as const };
+  });
+
+  ipcMain.handle('notebook:reorder', (_e, id: string, direction: 'up' | 'down') => deps.repo.reorder(id, direction));
+}

src/main/ipc/settingsApi.ts

@@ -1,16 +1,21 @@
 import electron from 'electron';
 import type { BrowserWindow } from 'electron';
 import { platform, release, EOL } from 'node:os';
+import { mkdir } from 'node:fs/promises';
 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 { GitClient } from '../services/GitClient.js';
 import type { TelemetryService } from '../services/TelemetryService.js';
 import type { SettingsService } from '../services/SettingsService.js';
+import type { SyncTimer } from '../services/SyncTimer.js';
 import { collectAutostartState } from '../services/AutostartDiagnostic.js';
 import { getInboxWindow as getInboxWindowSingleton } from '../windows/inboxWindow.js';
+import { refreshVisionCache } from '../services/VisionDetect.js';
+import { DEFAULT_OLLAMA_ENDPOINT } from '../../shared/constants.js';
 
 /**
  * 외부 (트레이 / second-instance / 기타 main 프로세스 호출자) 에서 inbox 창에 view 전환을
@@ -36,6 +41,7 @@ export interface SettingsIpcDeps {
   telemetry: TelemetryService;
   settings: SettingsService;
   getInboxWindow: () => BrowserWindow | null;
+  syncTimer?: SyncTimer;
 }
 
 /**
@@ -106,6 +112,33 @@ export function registerSettingsApi(deps?: SettingsIpcDeps): void {
     return { ok: true as const };
   });
 
+  // v0.4 — Sidebar UI state 영속화
+  ipcMain.handle('settings:set-sidebar-visible', async (_e, visible: boolean) => {
+    await settings.setSidebarVisible(visible);
+    return { ok: true as const };
+  });
+
+  ipcMain.handle('settings:set-sidebar-width', async (_e, width: number) => {
+    await settings.setSidebarWidth(width);
+    return { ok: true as const };
+  });
+
+  ipcMain.handle('settings:set-sync-auto-enabled', async (_e, value: boolean) => {
+    await deps.settings.setAutoSyncEnabled(value);
+    await deps.syncTimer?.reconfigure();
+    return { ok: true as const };
+  });
+
+  ipcMain.handle('settings:set-sync-interval-min', async (_e, value: number) => {
+    try {
+      await deps.settings.setSyncIntervalMin(value);
+      await deps.syncTimer?.reconfigure();
+      return { ok: true as const };
+    } catch (e) {
+      return { ok: false as const, reason: (e as Error).message };
+    }
+  });
+
   ipcMain.handle('settings:run-backup', async () => {
     try {
       const r = await backup.runDaily();
@@ -239,7 +272,7 @@ export function registerSettingsApi(deps?: SettingsIpcDeps): void {
         return { ok: true } as const;
       }
       if (r.changed) {
-        logger.info('sync.done', { sha: r.sha, pushed: r.pushed });
+        logger.info('sync.done', { sha: r.localSha, pushed: r.pushed });
         new Notification({ title: 'Inkling', body: '동기화 완료', silent: true }).show();
       } else {
         new Notification({ title: 'Inkling', body: '변경 사항 없음', silent: true }).show();
@@ -281,4 +314,112 @@ export function registerSettingsApi(deps?: SettingsIpcDeps): void {
     }
     return { ok: true } as const;
   });
+
+  // v0.3.0 Cut E — sync IPC.
+
+  // settings:configure-sync — URL 저장 + git init + remote add (없으면).
+  // null URL → 저장만 (init 안 함). 빈 문자열도 null 처리.
+  ipcMain.handle('settings:configure-sync', async (_e, url: string | null) => {
+    const trimmed = typeof url === 'string' ? url.trim() : '';
+    const finalUrl = trimmed.length === 0 ? null : trimmed;
+
+    try {
+      await deps.settings.setSyncRepoUrl(finalUrl);
+    } catch (e) {
+      return { ok: false as const, reason: `persist failed: ${(e as Error).message}` };
+    }
+
+    if (finalUrl === null) {
+      await deps.syncTimer?.reconfigure();
+      return { ok: true as const };
+    }
+
+    // git init + remote add origin
+    const syncDir = deps.syncSvc.getSyncDir();
+    try {
+      await mkdir(syncDir, { recursive: true });
+    } catch (e) {
+      return { ok: false as const, reason: `mkdir failed: ${(e as Error).message}` };
+    }
+    const git = new GitClient(syncDir);
+
+    if (!(await git.isRepo())) {
+      const init = await git.run(['init']);
+      if (init.exitCode !== 0) {
+        return { ok: false as const, reason: `git init failed: ${init.stderr}` };
+      }
+    }
+    if (!(await git.hasRemote())) {
+      const add = await git.run(['remote', 'add', 'origin', finalUrl]);
+      if (add.exitCode !== 0) {
+        return { ok: false as const, reason: `remote add failed: ${add.stderr}` };
+      }
+    } else {
+      // remote exists — update URL
+      const set = await git.run(['remote', 'set-url', 'origin', finalUrl]);
+      if (set.exitCode !== 0) {
+        return { ok: false as const, reason: `remote set-url failed: ${set.stderr}` };
+      }
+    }
+    await deps.syncTimer?.reconfigure();
+    return { ok: true as const };
+  });
+
+  // settings:test-sync-connection — git ls-remote 결과
+  ipcMain.handle('settings:test-sync-connection', async () => {
+    const syncDir = deps.syncSvc.getSyncDir();
+    const git = new GitClient(syncDir);
+    if (!(await git.isRepo())) return { ok: false as const, reason: 'not_initialized' };
+    const r = await git.run(['ls-remote', 'origin']);
+    if (r.exitCode !== 0) return { ok: false as const, reason: r.stderr || 'connection failed' };
+    return { ok: true as const };
+  });
+
+  // sync:list-conflicts — SyncService 캐시 결과
+  ipcMain.handle('sync:list-conflicts', () => deps.syncSvc.listConflicts());
+
+  // sync:resolve-conflict — local/remote 2 choice. path = git index conflict 경로.
+  ipcMain.handle('sync:resolve-conflict', async (_e, path: string, choice: 'local' | 'remote') => {
+    if (choice !== 'local' && choice !== 'remote') {
+      return { ok: false as const, reason: 'invalid choice' };
+    }
+    return deps.syncSvc.resolveConflict(path, choice);
+  });
+
+  // sync:get-status — lastAt + lastResult + nextAt 계산
+  ipcMain.handle('sync:get-status', async () => {
+    const last = deps.syncSvc.getLastStatus();
+    let nextAt: string | null = null;
+    if (await deps.settings.isAutoSyncEnabled()) {
+      const intervalMin = await deps.settings.getSyncIntervalMin();
+      const baseMs = last.lastAt ? new Date(last.lastAt).getTime() : Date.now();
+      nextAt = new Date(baseMs + intervalMin * 60 * 1000).toISOString();
+    }
+    return { lastAt: last.lastAt, lastResult: last.lastResult, nextAt };
+  });
+
+  // v0.3.1 Cut F — vision IPC
+
+  ipcMain.handle('settings:get-vision-models', async () => {
+    const cache = await deps.settings.getVisionCapableCache();
+    const selected = await deps.settings.getVisionModel();
+    return { models: cache.models, at: cache.at, selected };
+  });
+
+  ipcMain.handle('settings:set-vision-model', async (_e, value: string | null) => {
+    const sanitized = typeof value === 'string' && value.trim().length > 0 ? value.trim() : null;
+    await deps.settings.setVisionModel(sanitized);
+    return { ok: true as const };
+  });
+
+  ipcMain.handle('settings:refresh-vision-cache', async () => {
+    // Cut F final review fix — index.ts 의 resolvedEndpoint (settings → env → default)
+    // 와 동일한 fallback 체인 사용. settings.ollama 미설정 + env / default 만 있는 dev
+    // 환경에서도 manual "다시 감지" 가 동작하도록.
+    const all = await deps.settings.getAll();
+    const endpoint = all.ollama?.endpoint
+                  ?? process.env.INKLING_OLLAMA_ENDPOINT
+                  ?? DEFAULT_OLLAMA_ENDPOINT;
+    return refreshVisionCache({ settings: deps.settings, endpoint });
+  });
 }

src/main/repository/NoteRepository.ts

@@ -1,7 +1,8 @@
 import type Database from 'better-sqlite3';
 import { v7 as uuidv7, v4 as uuidv4 } from 'uuid';
 import type { AiStatus, Note, NoteMedia, NoteRevision, NoteStatus, NoteTag } from '@shared/types';
-import { kstTodayIso } from '../../shared/util/kstDate.js';
+import { kstTodayIso, KST_OFFSET_MS } from '../../shared/util/kstDate.js';
+import { sanitizeFtsQuery, computeCutoff, type ReviewPeriod } from './ftsHelpers.js';
 
 export interface CreateNoteInput {
   rawText: string;
@@ -10,6 +11,10 @@ export interface CreateNoteInput {
    * 미지정 시 기존 'pending' default + pending_jobs enqueue (backward compat).
    */
   aiStatus?: AiStatus;
+  /**
+   * v0.4 — 미지정 시 가장 오래된 notebook (default notebook) 의 id 자동 사용.
+   */
+  notebookId?: string;
 }
 
 export interface NewMediaRow {
@@ -50,36 +55,70 @@ export interface ImportNoteResult {
   status: ImportNoteStatus;
 }
 
+export interface UpsertFromSyncInput {
+  id: string;
+  rawText: string;
+  createdAt: string;
+  updatedAt: string;
+  aiTitle: string | null;
+  aiSummary: string | null;
+  titleEditedByUser: boolean;
+  summaryEditedByUser: boolean;
+  aiProvider: string | null;
+  aiGeneratedAt: string | null;
+  userIntent: string | null;
+  intentPromptedAt: string | null;
+  tags: { name: string; source: 'ai' | 'user' }[];
+  status: NoteStatus;
+  statusChangedAt: string | null;
+  moveReason: string | null;
+  dueDate: string | null;
+  dueDateEditedByUser: boolean;
+}
+
+export type UpsertFromSyncStatus = 'inserted' | 'updated' | 'skipped';
+
 const KEBAB_CASE_RE = /^[a-z0-9-]+$/;
 
 export class NoteRepository {
   constructor(private db: Database.Database) {}
 
-  create(input: CreateNoteInput): { id: string } {
+  create(input: CreateNoteInput, now: Date = new Date()): { id: string } {
     const id = uuidv7();
-    const now = new Date().toISOString();
+    const ts = now.toISOString();
     const aiStatus: AiStatus = input.aiStatus ?? 'pending';
+    const notebookId = input.notebookId ?? this.getDefaultNotebookId();
     const tx = this.db.transaction(() => {
       this.db
-        .prepare(`INSERT INTO notes (id, raw_text, ai_status, created_at, updated_at)
-                  VALUES (?, ?, ?, ?, ?)`)
-        .run(id, input.rawText, aiStatus, now, now);
+        .prepare(`INSERT INTO notes (id, raw_text, ai_status, created_at, updated_at, notebook_id)
+                  VALUES (?, ?, ?, ?, ?, ?)`)
+        .run(id, input.rawText, aiStatus, ts, ts, notebookId);
       this.db
         .prepare(`INSERT INTO note_revisions (note_id, raw_text, edited_at, edited_by)
                   VALUES (?, ?, ?, 'capture')`)
-        .run(id, input.rawText, now);
+        .run(id, input.rawText, ts);
       // pending_jobs 는 'pending' 일 때만 생성 — 'disabled' 노트는 worker 가 처리 안 함.
       if (aiStatus === 'pending') {
         this.db
           .prepare(`INSERT INTO pending_jobs (note_id, attempts, next_run_at)
                     VALUES (?, 0, ?)`)
-          .run(id, now);
+          .run(id, ts);
       }
     });
     tx();
     return { id };
   }
 
+  private getDefaultNotebookId(): string {
+    const r = this.db
+      .prepare(`SELECT id FROM notebooks ORDER BY created_at ASC LIMIT 1`)
+      .get() as { id: string } | undefined;
+    if (!r) {
+      throw new Error('No default notebook found — m008 migration may not have run');
+    }
+    return r.id;
+  }
+
   insertMedia(rows: NewMediaRow[]): void {
     if (rows.length === 0) return;
     const now = new Date().toISOString();
@@ -101,23 +140,15 @@ export class NoteRepository {
     return this.hydrate(row);
   }
 
-  list(opts: { limit: number; cursor?: string }): Note[] {
+  list(opts: { limit: number; cursor?: string; notebookId?: string }): Note[] {
     const limit = Math.max(1, Math.min(200, opts.limit));
-    const rows = opts.cursor
-      ? (this.db
-          .prepare(
-            `SELECT * FROM notes
-              WHERE deleted_at IS NULL AND created_at < ?
-              ORDER BY created_at DESC, id DESC LIMIT ?`
-          )
-          .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 Record<string, unknown>[]);
+    const params: unknown[] = [];
+    let sql = `SELECT * FROM notes WHERE deleted_at IS NULL`;
+    if (opts.notebookId) { sql += ` AND notebook_id = ?`; params.push(opts.notebookId); }
+    if (opts.cursor) { sql += ` AND created_at < ?`; params.push(opts.cursor); }
+    sql += ` ORDER BY created_at DESC, id DESC LIMIT ?`;
+    params.push(limit);
+    const rows = this.db.prepare(sql).all(...params) as Record<string, unknown>[];
     return rows.map((r) => this.hydrate(r));
   }
 
@@ -161,6 +192,7 @@ export class NoteRepository {
         linkTag.run(id, tagRow.id);
       }
       this.db.prepare(`DELETE FROM pending_jobs WHERE note_id=?`).run(id);
+      this.rebuildFtsTagsForNote(id);
     });
     tx();
   }
@@ -223,6 +255,70 @@ export class NoteRepository {
     return { ids };
   }
 
+  /**
+   * v0.3.9 — 단일 failed 노트 재시도. retryAllFailed 의 per-row 로직 동일.
+   * NoteCard 의 per-note "재시도" 버튼 path. failed 가 아닌 status 면 no-op.
+   */
+  retryOneFailed(id: string, now: string): { ok: boolean } {
+    const row = this.db
+      .prepare(`SELECT ai_status FROM notes WHERE id=? AND deleted_at IS NULL`)
+      .get(id) as { ai_status: string } | undefined;
+    if (!row || row.ai_status !== 'failed') return { ok: false };
+    const tx = this.db.transaction(() => {
+      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);
+    });
+    tx();
+    return { ok: true };
+  }
+
+  /**
+   * raw_text 편집/복원 직후 AI 재처리 트리거. done/failed/pending 노트를 pending 으로
+   * reset + pending_jobs row 보장 (attempts=0). disabled 는 사용자의 명시적 비활성화
+   * 의도 존중 — no-op. updateAiResult 의 user-edit 가드 (title_edited_by_user 등) 가
+   * 사용자가 직접 편집한 필드는 새 AI 결과로 덮어쓰지 않음.
+   */
+  markAiPendingForReprocess(id: string, now: string): { ok: boolean } {
+    const row = this.db
+      .prepare(`SELECT ai_status FROM notes WHERE id=? AND deleted_at IS NULL`)
+      .get(id) as { ai_status: string } | undefined;
+    if (!row || row.ai_status === 'disabled') return { ok: false };
+    const tx = this.db.transaction(() => {
+      this.db
+        .prepare(`UPDATE notes SET ai_status='pending', ai_error=NULL, updated_at=? WHERE id=?`)
+        .run(now, id);
+      this.db
+        .prepare(`INSERT OR REPLACE INTO pending_jobs (note_id, attempts, next_run_at) VALUES (?, 0, ?)`)
+        .run(id, now);
+    });
+    tx();
+    return { ok: true };
+  }
+
+  /**
+   * v0.3.9 — pending 노트의 AI 처리 cancel. ai_status='disabled' 로 전환 + pending_jobs 삭제.
+   * raw_text 는 보존. 사용자가 무한 pending (Ollama 끊김 등) 에서 빠져나오는 path.
+   * pending 외 status 면 no-op.
+   */
+  cancelPending(id: string, now: string): { ok: boolean } {
+    const row = this.db
+      .prepare(`SELECT ai_status FROM notes WHERE id=? AND deleted_at IS NULL`)
+      .get(id) as { ai_status: string } | undefined;
+    if (!row || row.ai_status !== 'pending') return { ok: false };
+    const tx = this.db.transaction(() => {
+      this.db
+        .prepare(`UPDATE notes SET ai_status='disabled', ai_error=NULL, updated_at=? WHERE id=?`)
+        .run(now, id);
+      this.db.prepare(`DELETE FROM pending_jobs WHERE note_id=?`).run(id);
+    });
+    tx();
+    return { ok: true };
+  }
+
   /**
    * v0.2.9 Cut B Task 16 — 모든 ai_status='disabled' 노트를 'pending' 으로 reset 하고
    * pending_jobs 재투입. 사용자가 settings.ai_enabled OFF→ON 전환 후 "지금 모두 처리"
@@ -390,6 +486,7 @@ export class NoteRepository {
           const row = getOrInsert.get(t) as { id: number };
           link.run(id, row.id);
         }
+        this.rebuildFtsTagsForNote(id);
       }
     });
     tx();
@@ -573,29 +670,116 @@ export class NoteRepository {
   /**
    * v0.2.9 Cut B Task 4 — status 별 row count. 4탭 헤더 badge 용.
    * tags/media hydrate 없음 (cheap path, listByStatus 와 별도).
+   * v0.4 — notebookId 옵션 추가. 미지정 시 전체 notebook.
    */
-  countByStatus(status: NoteStatus): number {
-    const row = this.db
-      .prepare(`SELECT COUNT(*) AS c FROM notes WHERE status = ?`)
-      .get(status) as { c: number };
-    return row.c;
+  countByStatus(status: NoteStatus, opts: { notebookId?: string } = {}): number {
+    const params: unknown[] = [status];
+    let sql = `SELECT COUNT(*) AS c FROM notes WHERE status = ?`;
+    if (opts.notebookId) { sql += ` AND notebook_id = ?`; params.push(opts.notebookId); }
+    const r = this.db.prepare(sql).get(...params) as { c: number };
+    return r.c;
   }
 
   /**
    * v0.2.9 Cut B — status 별 노트 목록. status_changed_at DESC (최근 전이 우선),
    * NULL 은 created_at fallback. limit cap 200 (list/listTrashed 와 동일).
+   * v0.4 — notebookId 옵션 추가. 미지정 시 전체 notebook.
    */
-  listByStatus(status: NoteStatus, opts: { limit?: number } = {}): Note[] {
+  listByStatus(status: NoteStatus, opts: { limit?: number; notebookId?: string } = {}): Note[] {
     const limit = Math.max(1, Math.min(200, opts.limit ?? 200));
-    const rows = this.db
+    const params: unknown[] = [status];
+    let sql = `SELECT * FROM notes WHERE status = ?`;
+    if (opts.notebookId) { sql += ` AND notebook_id = ?`; params.push(opts.notebookId); }
+    sql += ` ORDER BY COALESCE(status_changed_at, created_at) DESC, id DESC LIMIT ?`;
+    params.push(limit);
+    const rows = this.db.prepare(sql).all(...params) as Record<string, unknown>[];
+    return rows.map((r) => this.hydrate(r));
+  }
+
+  /**
+   * v0.2.11 Cut D — FTS5 검색. notes_fts MATCH + rank 정렬 + 기본 trashed 제외.
+   * 빈/공백 query → []. multi-token 은 implicit AND. FTS5 special chars 는 sanitize.
+   * v0.4 — notebookId 옵션 추가. 미지정 시 전체 notebook.
+   */
+  search(query: string, opts: { limit?: number; status?: NoteStatus; notebookId?: string } = {}): Note[] {
+    const sanitized = sanitizeFtsQuery(query);
+    if (sanitized.length === 0) return [];
+    const limit = Math.max(1, Math.min(200, opts.limit ?? 50));
+    const statusClause = opts.status ? `AND n.status = ?` : `AND n.status != 'trashed'`;
+    const notebookClause = opts.notebookId ? `AND n.notebook_id = ?` : ``;
+    const sql = `
+      SELECT n.* FROM notes n
+      JOIN notes_fts f ON n.id = f.note_id
+      WHERE notes_fts MATCH ? ${statusClause} ${notebookClause}
+      ORDER BY rank
+      LIMIT ?
+    `;
+    const args: unknown[] = [sanitized];
+    if (opts.status) args.push(opts.status);
+    if (opts.notebookId) args.push(opts.notebookId);
+    args.push(limit);
+    const rows = this.db.prepare(sql).all(...args) as Record<string, unknown>[];
+    return rows.map((r) => this.hydrate(r));
+  }
+
+  /**
+   * v0.2.11 Cut D — 회고 view aggregate. period 별 KST 자정 cutoff 이후 노트
+   * (status != 'trashed') 의 totalCount / recentNotes(50) / tagCounts(DESC) /
+   * dueProgress(passed/pending KST today 기준).
+   */
+  reviewAggregate(period: ReviewPeriod, now: Date = new Date()): {
+    totalCount: number;
+    recentNotes: Note[];
+    tagCounts: Array<{ tag: string; count: number }>;
+    dueProgress: { total: number; passed: number; pending: number };
+  } {
+    const cutoff = computeCutoff(period, now);
+    const todayIso = kstTodayIso(now);
+
+    const totalCount = (this.db
+      .prepare(`SELECT COUNT(*) AS c FROM notes WHERE created_at >= ? AND status != 'trashed'`)
+      .get(cutoff) as { c: number }).c;
+
+    const recentRows = this.db
       .prepare(
         `SELECT * FROM notes
-          WHERE status = ?
-          ORDER BY COALESCE(status_changed_at, created_at) DESC, id DESC
-          LIMIT ?`
+          WHERE created_at >= ? AND status != 'trashed'
+          ORDER BY created_at DESC, id DESC LIMIT 50`
       )
-      .all(status, limit) as Record<string, unknown>[];
-    return rows.map((r) => this.hydrate(r));
+      .all(cutoff) as Record<string, unknown>[];
+    const recentNotes = recentRows.map((r) => this.hydrate(r));
+
+    const tagCounts = this.db
+      .prepare(
+        `SELECT t.name AS tag, COUNT(*) AS count
+           FROM note_tags nt
+           JOIN notes n ON n.id = nt.note_id
+           JOIN tags t ON t.id = nt.tag_id
+          WHERE n.created_at >= ? AND n.status != 'trashed'
+          GROUP BY t.id
+          ORDER BY count DESC, t.name ASC`
+      )
+      .all(cutoff) as Array<{ tag: string; count: number }>;
+
+    const dueRow = this.db
+      .prepare(
+        `SELECT
+           COUNT(*) AS total,
+           SUM(CASE WHEN due_date < ? THEN 1 ELSE 0 END) AS passed,
+           SUM(CASE WHEN due_date >= ? THEN 1 ELSE 0 END) AS pending
+         FROM notes
+         WHERE created_at >= ?
+           AND status != 'trashed'
+           AND due_date IS NOT NULL`
+      )
+      .get(todayIso, todayIso, cutoff) as { total: number; passed: number | null; pending: number | null };
+    const dueProgress = {
+      total: dueRow.total,
+      passed: dueRow.passed ?? 0,
+      pending: dueRow.pending ?? 0
+    };
+
+    return { totalCount, recentNotes, tagCounts, dueProgress };
   }
 
   /**
@@ -696,6 +880,11 @@ export class NoteRepository {
    * 'capture' 첫 revision INSERT (createdAt = edited_at). 미수행 시 first user
    * edit 직후 import 시점 본문이 history 에서 사라지는 회귀 (final review 발견).
    *
+   * v0.2.11 Cut D — INSERT/fork 시 tags 추가 후 rebuildFtsTagsForNote(finalId)
+   * 호출 — m007 trigger 가 빈 tags='' 로 FTS row 만들고, note_tags INSERT 만으로는
+   * notes_fts.tags 갱신 안 됨. 미수행 시 import 한 노트가 tag keyword 검색에서
+   * 매칭 안 되는 회귀 (final review 발견).
+   *
    * deletedAt merge (v0.2.3 #4, spec §8.2): source/dest 중 IS NOT NULL 우선
    * (삭제 보존). skip 케이스에서 source NN + dest NULL 일 때만 dest 갱신.
    * insert/fork 는 source 의 deletedAt 그대로 보존.
@@ -721,14 +910,15 @@ export class NoteRepository {
       finalId = uuidv7();
       status = 'forked';
     }
+    const notebookId = this.getDefaultNotebookId();
     const tx = this.db.transaction(() => {
       this.db
         .prepare(
           `INSERT INTO notes
              (id, raw_text, ai_title, ai_summary, ai_status, ai_provider, ai_generated_at,
               title_edited_by_user, summary_edited_by_user,
-              user_intent, intent_prompted_at, deleted_at, created_at, updated_at)
-           VALUES (?, ?, ?, ?, 'done', ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+              user_intent, intent_prompted_at, deleted_at, created_at, updated_at, notebook_id)
+           VALUES (?, ?, ?, ?, 'done', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
         )
         .run(
           finalId,
@@ -743,7 +933,8 @@ export class NoteRepository {
           input.intentPromptedAt,
           input.deletedAt ?? null,
           input.createdAt,
-          input.updatedAt
+          input.updatedAt,
+          notebookId
         );
       this.db
         .prepare(
@@ -766,12 +957,153 @@ export class NoteRepository {
           if (t.source === 'ai') linkAi.run(finalId, row.id);
           else linkUser.run(finalId, row.id);
         }
+        // v0.2.11 Cut D — note_tags 변경 후 notes_fts.tags 동기화 (single write path).
+        this.rebuildFtsTagsForNote(finalId);
       }
     });
     tx();
     return { id: finalId, status };
   }
 
+  /**
+   * v0.3.0 Cut E — sync 전용 upsert. 기존 importNote 의 fork-on-id-collision 정책은
+   * sync 에 부적합 (양 기기 raw_text 가 다를 때마다 fork → 노트 갯수 무한 증가).
+   *
+   * 3 분기:
+   * - id 없음 → INSERT (capture revision + tags FTS sync)
+   * - id 있음 + raw_text 동일 → source.updatedAt 가 더 최신일 때만 metadata 갱신
+   * - id 있음 + raw_text 다름 → source 가 더 최신이면 updateRawText (new user revision),
+   *   local 이 더 최신이면 skip
+   *
+   * tags 변경 시 rebuildFtsTagsForNote 호출 — Cut D single write path 재사용.
+   * raw_text 변경 시 updateRawText 호출 — Cut C single write path 재사용.
+   */
+  upsertFromSync(input: UpsertFromSyncInput): { id: string; status: UpsertFromSyncStatus } {
+    const existing = this.db
+      .prepare(`SELECT raw_text, updated_at, status FROM notes WHERE id=?`)
+      .get(input.id) as { raw_text: string; updated_at: string; status: NoteStatus } | undefined;
+
+    if (!existing) {
+      // INSERT path
+      const notebookId = this.getDefaultNotebookId();
+      const tx = this.db.transaction(() => {
+        this.db
+          .prepare(
+            `INSERT INTO notes
+               (id, raw_text, ai_title, ai_summary, ai_status, ai_provider, ai_generated_at,
+                title_edited_by_user, summary_edited_by_user,
+                user_intent, intent_prompted_at,
+                created_at, updated_at,
+                due_date, due_date_edited_by_user,
+                status, status_changed_at, move_reason, notebook_id)
+             VALUES (?, ?, ?, ?, 'done', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+          )
+          .run(
+            input.id,
+            input.rawText,
+            input.aiTitle,
+            input.aiSummary,
+            input.aiProvider,
+            input.aiGeneratedAt,
+            input.titleEditedByUser ? 1 : 0,
+            input.summaryEditedByUser ? 1 : 0,
+            input.userIntent,
+            input.intentPromptedAt,
+            input.createdAt,
+            input.updatedAt,
+            input.dueDate,
+            input.dueDateEditedByUser ? 1 : 0,
+            input.status,
+            input.statusChangedAt,
+            input.moveReason,
+            notebookId
+          );
+        this.db
+          .prepare(
+            `INSERT INTO note_revisions (note_id, raw_text, edited_at, edited_by)
+             VALUES (?, ?, ?, 'capture')`
+          )
+          .run(input.id, input.rawText, input.createdAt);
+        if (input.tags.length > 0) {
+          const getOrInsertTag = this.db.prepare(
+            `INSERT INTO tags(name) VALUES(?) ON CONFLICT(name) DO UPDATE SET name=name RETURNING id`
+          );
+          const linkAi = this.db.prepare(
+            `INSERT OR IGNORE INTO note_tags(note_id, tag_id, source) VALUES(?, ?, 'ai')`
+          );
+          const linkUser = this.db.prepare(
+            `INSERT OR IGNORE INTO note_tags(note_id, tag_id, source) VALUES(?, ?, 'user')`
+          );
+          for (const t of input.tags) {
+            const row = getOrInsertTag.get(t.name) as { id: number };
+            if (t.source === 'ai') linkAi.run(input.id, row.id);
+            else linkUser.run(input.id, row.id);
+          }
+          this.rebuildFtsTagsForNote(input.id);
+        }
+      });
+      tx();
+      return { id: input.id, status: 'inserted' };
+    }
+
+    if (input.updatedAt <= existing.updated_at) {
+      return { id: input.id, status: 'skipped' };
+    }
+
+    if (existing.raw_text !== input.rawText) {
+      this.updateRawText(input.id, input.rawText, new Date(input.updatedAt));
+    }
+
+    const tx = this.db.transaction(() => {
+      this.db
+        .prepare(
+          `UPDATE notes
+              SET ai_title = CASE WHEN title_edited_by_user = 1 THEN ai_title ELSE ? END,
+                  ai_summary = CASE WHEN summary_edited_by_user = 1 THEN ai_summary ELSE ? END,
+                  ai_provider = ?,
+                  ai_generated_at = ?,
+                  due_date = CASE WHEN due_date_edited_by_user = 1 THEN due_date ELSE ? END,
+                  status = ?,
+                  status_changed_at = ?,
+                  move_reason = ?,
+                  updated_at = ?
+            WHERE id = ?`
+        )
+        .run(
+          input.aiTitle,
+          input.aiSummary,
+          input.aiProvider,
+          input.aiGeneratedAt,
+          input.dueDate,
+          input.status,
+          input.statusChangedAt,
+          input.moveReason,
+          input.updatedAt,
+          input.id
+        );
+      this.db.prepare(`DELETE FROM note_tags WHERE note_id=?`).run(input.id);
+      if (input.tags.length > 0) {
+        const getOrInsertTag = this.db.prepare(
+          `INSERT INTO tags(name) VALUES(?) ON CONFLICT(name) DO UPDATE SET name=name RETURNING id`
+        );
+        const linkAi = this.db.prepare(
+          `INSERT OR IGNORE INTO note_tags(note_id, tag_id, source) VALUES(?, ?, 'ai')`
+        );
+        const linkUser = this.db.prepare(
+          `INSERT OR IGNORE INTO note_tags(note_id, tag_id, source) VALUES(?, ?, 'user')`
+        );
+        for (const t of input.tags) {
+          const row = getOrInsertTag.get(t.name) as { id: number };
+          if (t.source === 'ai') linkAi.run(input.id, row.id);
+          else linkUser.run(input.id, row.id);
+        }
+      }
+      this.rebuildFtsTagsForNote(input.id);
+    });
+    tx();
+    return { id: input.id, status: 'updated' };
+  }
+
   getPendingCount(): number {
     const row = this.db
       .prepare(
@@ -788,7 +1120,6 @@ export class NoteRepository {
    * and count rows whose UTC ISO `created_at` lies inside.
    */
   countToday(now: Date = new Date()): number {
-    const KST_OFFSET_MS = 9 * 60 * 60 * 1000;
     const kstNow = new Date(now.getTime() + KST_OFFSET_MS);
     const kstYear = kstNow.getUTCFullYear();
     const kstMonth = kstNow.getUTCMonth();
@@ -807,9 +1138,12 @@ export class NoteRepository {
   }
 
   /**
-   * Notes whose due_date is strictly before today (KST calendar) and that are
-   * still active (not trashed) and AI-processed. Includes both AI-extracted and
-   * user-edited due_date (v0.2.3 #5 spec §1 Q1=B).
+   * Notes whose due_date is today (KST calendar) or already past, that are still
+   * active (inbox only — completed/archived/trashed 제외), and AI-processed.
+   * Includes both AI-extracted and user-edited due_date.
+   *
+   * 정렬: due_date DESC → 오늘 당일 먼저, 그 다음 어제, 그 전... 같은 due_date 내에선
+   * created_at DESC, id DESC tiebreak.
    *
    * Caller may inject `now` for testability; defaults to `new Date()`.
    */
@@ -819,15 +1153,38 @@ export class NoteRepository {
       .prepare(
         `SELECT * FROM notes
           WHERE due_date IS NOT NULL
-            AND due_date < ?
+            AND due_date <= ?
             AND deleted_at IS NULL
+            AND status = 'active'
             AND ai_status = 'done'
-          ORDER BY created_at DESC, id DESC`
+          ORDER BY due_date DESC, created_at DESC, id DESC`
       )
       .all(today) as Record<string, unknown>[];
     return rows.map((r) => this.hydrate(r));
   }
 
+  /**
+   * v0.4 Task 5 — default notebook 안 active 노트를 tag 기준으로 cluster 하여
+   * threshold 이상인 tag + noteIds 배열 반환. notebook 승격 제안 트리거용.
+   * completed/trashed/non-default-notebook 제외.
+   */
+  findPromotionCandidates(
+    defaultNotebookId: string,
+    threshold: number = 3
+  ): Array<{ tag: string; noteIds: string[] }> {
+    const rows = this.db.prepare(
+      `SELECT t.name AS tag, GROUP_CONCAT(n.id) AS ids, COUNT(DISTINCT n.id) AS cnt
+         FROM tags t
+         JOIN note_tags nt ON nt.tag_id = t.id
+         JOIN notes n ON n.id = nt.note_id
+        WHERE n.status = 'active'
+          AND n.notebook_id = ?
+        GROUP BY t.id
+       HAVING cnt >= ?`
+    ).all(defaultNotebookId, threshold) as Array<{ tag: string; ids: string; cnt: number }>;
+    return rows.map((r) => ({ tag: r.tag, noteIds: r.ids.split(',') }));
+  }
+
   getAllPendingJobs(): Array<{ noteId: string; attempts: number; nextRunAt: string }> {
     const rows = this.db
       .prepare(`SELECT note_id, attempts, next_run_at FROM pending_jobs`)
@@ -851,6 +1208,23 @@ export class NoteRepository {
       .run(nextRunAt, lastError.slice(0, 500), noteId);
   }
 
+  /**
+   * v0.2.11 Cut D — note_tags 변경 후 notes_fts.tags 컬럼 (csv) 재구성.
+   * 단일 write path 패턴: tags 변경하는 모든 메서드가 같은 transaction 끝에서 호출.
+   */
+  private rebuildFtsTagsForNote(noteId: string): void {
+    const row = this.db
+      .prepare(
+        `SELECT COALESCE(GROUP_CONCAT(t.name, ' '), '') AS csv
+           FROM note_tags nt JOIN tags t ON t.id = nt.tag_id
+          WHERE nt.note_id = ?`
+      )
+      .get(noteId) as { csv: string };
+    this.db
+      .prepare(`UPDATE notes_fts SET tags = ? WHERE note_id = ?`)
+      .run(row.csv, noteId);
+  }
+
   private hydrate(row: Record<string, unknown>): Note {
     const tags = this.db
       .prepare(
@@ -888,7 +1262,8 @@ export class NoteRepository {
       createdAt: row.created_at as string,
       updatedAt: row.updated_at as string,
       tags: tags as NoteTag[],
-      media
+      media,
+      notebookId: row.notebook_id as string
     };
   }
 }

src/main/repository/NotebookRepository.ts

@@ -0,0 +1,123 @@
+import type Database from 'better-sqlite3';
+import { v7 as uuidv7 } from 'uuid';
+import type { Notebook } from '@shared/types';
+
+export class NotebookRepository {
+  constructor(private db: Database.Database) {}
+
+  list(): Notebook[] {
+    const rows = this.db.prepare(
+      `SELECT nb.id, nb.name, nb.color, nb.created_at, nb.updated_at,
+              (SELECT COUNT(*) FROM notes n
+                WHERE n.notebook_id = nb.id AND n.status = 'active') AS note_count
+         FROM notebooks nb
+        ORDER BY nb.sort_order ASC, nb.name ASC`
+    ).all() as Array<Record<string, unknown>>;
+    return rows.map((r) => this.hydrate(r));
+  }
+
+  findById(id: string): Notebook | null {
+    const r = this.db.prepare(
+      `SELECT nb.id, nb.name, nb.color, nb.created_at, nb.updated_at,
+              (SELECT COUNT(*) FROM notes n
+                WHERE n.notebook_id = nb.id AND n.status = 'active') AS note_count
+         FROM notebooks nb WHERE nb.id = ?`
+    ).get(id) as Record<string, unknown> | undefined;
+    return r ? this.hydrate(r) : null;
+  }
+
+  /** name 은 COLLATE NOCASE UNIQUE — case-insensitive 중복 거부. */
+  create(input: { name: string; color?: string | null }): Notebook {
+    const id = uuidv7();
+    const now = new Date().toISOString();
+    const maxRow = this.db.prepare(`SELECT COALESCE(MAX(sort_order), -1) AS m FROM notebooks`).get() as { m: number };
+    const sortOrder = maxRow.m + 1;
+    this.db.prepare(
+      `INSERT INTO notebooks(id, name, color, created_at, updated_at, sort_order) VALUES(?,?,?,?,?,?)`
+    ).run(id, input.name, input.color ?? null, now, now, sortOrder);
+    return { id, name: input.name, color: input.color ?? null, createdAt: now, updatedAt: now, noteCount: 0 };
+  }
+
+  reorder(id: string, direction: 'up' | 'down'): { ok: boolean } {
+    const cur = this.db.prepare(`SELECT sort_order FROM notebooks WHERE id = ?`).get(id) as { sort_order: number } | undefined;
+    if (!cur) return { ok: false };
+    const neighbor = direction === 'up'
+      ? this.db.prepare(`SELECT id, sort_order FROM notebooks WHERE sort_order < ? ORDER BY sort_order DESC LIMIT 1`).get(cur.sort_order)
+      : this.db.prepare(`SELECT id, sort_order FROM notebooks WHERE sort_order > ? ORDER BY sort_order ASC LIMIT 1`).get(cur.sort_order);
+    if (!neighbor) return { ok: false };  // 이미 끝
+    const n = neighbor as { id: string; sort_order: number };
+    const now = new Date().toISOString();
+    const tx = this.db.transaction(() => {
+      this.db.prepare(`UPDATE notebooks SET sort_order = ?, updated_at = ? WHERE id = ?`).run(n.sort_order, now, id);
+      this.db.prepare(`UPDATE notebooks SET sort_order = ?, updated_at = ? WHERE id = ?`).run(cur.sort_order, now, n.id);
+    });
+    tx();
+    return { ok: true };
+  }
+
+  rename(id: string, name: string): void {
+    const now = new Date().toISOString();
+    this.db.prepare(`UPDATE notebooks SET name=?, updated_at=? WHERE id=?`).run(name, now, id);
+  }
+
+  setColor(id: string, color: string | null): void {
+    const now = new Date().toISOString();
+    this.db.prepare(`UPDATE notebooks SET color=?, updated_at=? WHERE id=?`).run(color, now, id);
+  }
+
+  /** FK RESTRICT 가 메모 잔류 시 throw — ok:false 로 변환. */
+  delete(id: string): { ok: true } | { ok: false; reason: 'has_notes' | 'not_found' } {
+    const exists = this.db.prepare(`SELECT 1 FROM notebooks WHERE id=?`).get(id);
+    if (!exists) return { ok: false, reason: 'not_found' };
+    try {
+      this.db.prepare(`DELETE FROM notebooks WHERE id=?`).run(id);
+      return { ok: true };
+    } catch (e) {
+      const msg = (e as Error).message;
+      if (msg.includes('FOREIGN KEY')) return { ok: false, reason: 'has_notes' };
+      throw e;
+    }
+  }
+
+  /** name 으로 notebook 조회 (COLLATE NOCASE — case-insensitive). */
+  findByName(name: string): Notebook | null {
+    const r = this.db.prepare(
+      `SELECT nb.id, nb.name, nb.color, nb.created_at, nb.updated_at,
+              (SELECT COUNT(*) FROM notes n
+                WHERE n.notebook_id = nb.id AND n.status = 'active') AS note_count
+         FROM notebooks nb WHERE nb.name = ? COLLATE NOCASE`
+    ).get(name) as Record<string, unknown> | undefined;
+    return r ? this.hydrate(r) : null;
+  }
+
+  /**
+   * v0.4 Task 11 — 가장 오래된 (created_at ASC LIMIT 1) notebook = default.
+   * m008 마이그레이션이 기존 노트를 자동으로 이 notebook 에 할당.
+   */
+  getDefault(): Notebook | null {
+    const r = this.db.prepare(
+      `SELECT nb.id, nb.name, nb.color, nb.created_at, nb.updated_at,
+              (SELECT COUNT(*) FROM notes n
+                WHERE n.notebook_id = nb.id AND n.status = 'active') AS note_count
+         FROM notebooks nb ORDER BY nb.created_at ASC LIMIT 1`
+    ).get() as Record<string, unknown> | undefined;
+    return r ? this.hydrate(r) : null;
+  }
+
+  /** notes.notebook_id 갱신만 (status 등은 보존). */
+  moveNote(noteId: string, notebookId: string): void {
+    this.db.prepare(`UPDATE notes SET notebook_id=?, updated_at=? WHERE id=?`)
+      .run(notebookId, new Date().toISOString(), noteId);
+  }
+
+  private hydrate(r: Record<string, unknown>): Notebook {
+    return {
+      id: r.id as string,
+      name: r.name as string,
+      color: (r.color as string | null) ?? null,
+      createdAt: r.created_at as string,
+      updatedAt: r.updated_at as string,
+      noteCount: r.note_count as number
+    };
+  }
+}

src/main/repository/ftsHelpers.ts

@@ -0,0 +1,35 @@
+/**
+ * v0.2.11 Cut D — FTS5 검색 + 회고 view 의 순수 함수 헬퍼.
+ */
+
+import { KST_OFFSET_MS } from '../../shared/util/kstDate.js';
+
+// FTS5 special chars: " * ( ) : 외에도 - (NOT 연산자), ^ (column prefix), ` (escape),
+// AND/OR/NOT keyword 도 query parser 가 special 처리. v0.3.9 — backtick/dash/caret 추가.
+// 한국어 사용자가 의도 없이 입력할 가능성 가장 높은 punctuation 까지 sanitize.
+const FTS5_SPECIAL_CHARS_RE = /["*():`^\-]/g;
+const WS_COLLAPSE_RE = /\s+/g;
+
+/**
+ * FTS5 MATCH 쿼리에 안전한 형태로 변환. special chars 공백 치환 + 공백 정리.
+ * 다중 토큰은 그대로 두어 FTS5 implicit AND 활용.
+ */
+export function sanitizeFtsQuery(input: string): string {
+  return input.replace(FTS5_SPECIAL_CHARS_RE, ' ').replace(WS_COLLAPSE_RE, ' ').trim();
+}
+
+export type ReviewPeriod = 'daily' | 'weekly' | 'monthly';
+
+/**
+ * 회고 cutoff = period 시작점의 KST 자정 (UTC ISO).
+ * daily = 오늘 0시, weekly = 7일 전 0시, monthly = 30일 전 0시.
+ */
+export function computeCutoff(period: ReviewPeriod, now: Date): string {
+  const kstNow = new Date(now.getTime() + KST_OFFSET_MS);
+  const y = kstNow.getUTCFullYear();
+  const m = kstNow.getUTCMonth();
+  const d = kstNow.getUTCDate();
+  const todayMidKstUtc = Date.UTC(y, m, d) - KST_OFFSET_MS;
+  const days = period === 'daily' ? 0 : period === 'weekly' ? 7 : 30;
+  return new Date(todayMidKstUtc - days * 24 * 60 * 60 * 1000).toISOString();
+}

src/main/services/AutostartDiagnostic.ts

@@ -13,6 +13,12 @@ export interface AutostartState {
   withArgs: { openAtLogin: boolean; executableWillLaunchAtLogin: boolean };
   noArgs: { openAtLogin: boolean; executableWillLaunchAtLogin: boolean };
   execPath: string;
+  /**
+   * 플랫폼 분기용. macOS 13+ 의 SMAppService API 는 args 옵션 무시 + unsigned/Electron
+   * 앱에 대해 executableWillLaunchAtLogin 이 false 를 반환할 수 있어, mismatch 판정에서
+   * 해당 신호를 제외해야 false positive 방지 가능.
+   */
+  platform: NodeJS.Platform;
   registryPath?: string;
   registryValue?: string | null;
 }
@@ -26,7 +32,8 @@ export async function collectAutostartState(): Promise<AutostartState> {
   const state: AutostartState = {
     withArgs: { openAtLogin: w.openAtLogin, executableWillLaunchAtLogin: w.executableWillLaunchAtLogin },
     noArgs: { openAtLogin: n.openAtLogin, executableWillLaunchAtLogin: n.executableWillLaunchAtLogin },
-    execPath: process.execPath
+    execPath: process.execPath,
+    platform: process.platform
   };
   if (process.platform === 'win32') {
     state.registryPath = `${WIN_REGISTRY_PATH}\\${WIN_REGISTRY_KEY}`;

src/main/services/BackupService.ts

@@ -2,8 +2,7 @@ import type Database from 'better-sqlite3';
 import { mkdir, rename, stat, readdir, unlink, readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { applyGfsRetention } from './backupRotation.js';
-
-const KST_OFFSET_MS = 9 * 60 * 60 * 1000;
+import { KST_OFFSET_MS } from '../../shared/util/kstDate.js';
 const MARKER_FILENAME = '.last-snapshot';
 
 function toKstDateKey(d: Date): string {

src/main/services/CaptureService.ts

@@ -146,9 +146,9 @@ export class CaptureService {
   }
 
   /**
-   * 만료 후보 (due_date < today KST, active, ai_status=done) 조회.
+   * 마감 임박 후보 (due_date ≤ today KST, status=active inbox, ai_status=done) 조회.
+   * 오늘 당일 마감 메모도 포함하여 사용자에게 미리 인지시킨다 (정렬은 due_date DESC).
    * candidates 가 비지 않고 signature 가 직전과 다르면 expired_banner_shown 자동 emit.
-   * v0.2.3 #5 spec §6.2 — dedup 위치 main 통합.
    */
   async listExpired(now: Date = new Date()): Promise<Note[]> {
     const candidates = this.repo.findExpiredCandidates(now);
@@ -207,6 +207,24 @@ export class CaptureService {
     return { count: ids.length };
   }
 
+  /**
+   * v0.3.9 — 단일 failed 노트 재시도. NoteCard 의 per-note "재시도" 버튼 path.
+   * repo.retryOneFailed 후 worker.enqueue 재투입.
+   */
+  async retryOneFailed(id: string): Promise<{ ok: boolean }> {
+    const r = this.repo.retryOneFailed(id, new Date().toISOString());
+    if (r.ok) await this.deps.enqueue(id);
+    return r;
+  }
+
+  /**
+   * v0.3.9 — pending 노트 cancel. ai_status='disabled' + pending_jobs 삭제.
+   * 사용자가 무한 pending (Ollama 끊김 등) 에서 빠져나오는 path.
+   */
+  cancelPending(id: string): { ok: boolean } {
+    return this.repo.cancelPending(id, new Date().toISOString());
+  }
+
   /** v0.2.3 #6 — 회상 후보 1건 fetch. */
   async listRecallCandidate(): Promise<Note | null> {
     return this.repo.findRecallCandidate();

src/main/services/ContinuityService.ts

@@ -1,7 +1,6 @@
 import type Database from 'better-sqlite3';
 import type { WeeklyContinuity } from '@shared/types';
-
-const KST_OFFSET_MS = 9 * 60 * 60 * 1000;
+import { KST_OFFSET_MS } from '../../shared/util/kstDate.js';
 const ONE_DAY_MS = 24 * 60 * 60 * 1000;
 const WEEK_TARGET = 7;
 const RECOVERY_GAP_DAYS = 7;

src/main/services/ExportService.ts

@@ -64,6 +64,11 @@ function noteToExportNote(n: Note): ExportNote {
     aiGeneratedAt: n.aiGeneratedAt,
     userIntent: n.userIntent,
     intentPromptedAt: n.intentPromptedAt,
+    status: n.status,
+    statusChangedAt: n.statusChangedAt,
+    moveReason: n.moveReason,
+    dueDate: n.dueDate,
+    dueDateEditedByUser: n.dueDateEditedByUser,
     tags: n.tags.map((t) => ({ name: t.name, source: t.source })),
     media: n.media.map((m, idx) => ({
       rel: `media/${n.id.slice(0, 8)}__${idx + 1}.${inferExt(m.mime)}`,
@@ -131,7 +136,6 @@ export class ExportService {
     totalBytes += Buffer.byteLength(indexJsonl, 'utf8');
 
     const manifest = composeManifest({
-      exportedAt: this.now().toISOString(),
       noteCount: notes.length,
       mediaCount
     });

src/main/services/GitClient.ts

@@ -89,4 +89,33 @@ export class GitClient {
     if (r.exitCode !== 0) throw new Error(`git rev-parse failed: ${r.stderr}`);
     return r.stdout.trim();
   }
+
+  async fetch(remote: string = 'origin'): Promise<GitExecResult> {
+    return this.run(['fetch', remote]);
+  }
+
+  async rebaseOnto(ref: string): Promise<GitExecResult> {
+    return this.run(['rebase', ref]);
+  }
+
+  async rebaseAbort(): Promise<GitExecResult> {
+    return this.run(['rebase', '--abort']);
+  }
+
+  async hasUncommittedChanges(): Promise<boolean> {
+    const r = await this.run(['status', '--porcelain']);
+    return r.stdout.trim().length > 0;
+  }
+
+  /** ref (branch, tag, remote branch) 존재 여부 확인. `git rev-parse --verify`. */
+  async refExists(ref: string): Promise<boolean> {
+    const r = await this.run(['rev-parse', '--verify', ref]);
+    return r.exitCode === 0;
+  }
+
+  /** rebase conflict 시 conflict 마킹된 파일 list. `git diff --name-only --diff-filter=U`. */
+  async listConflicts(): Promise<string[]> {
+    const r = await this.run(['diff', '--name-only', '--diff-filter=U']);
+    return r.stdout.split('\n').map((s) => s.trim()).filter((s) => s.length > 0);
+  }
 }

src/main/services/ImportService.ts

@@ -130,6 +130,39 @@ export class ImportService {
     };
   }
 
+  async applySyncFromDir(dir: string): Promise<{ changedCount: number }> {
+    const files = await this.scanNotes(dir);
+    let changedCount = 0;
+    for (const f of files) {
+      const content = await readFile(f, 'utf8');
+      const parsed = parseExportNote(content);
+      const r = this.repo.upsertFromSync({
+        id: parsed.id,
+        rawText: parsed.rawText,
+        createdAt: parsed.createdAt,
+        updatedAt: parsed.updatedAt,
+        aiTitle: parsed.aiTitle,
+        aiSummary: parsed.aiSummary,
+        titleEditedByUser: parsed.titleEditedByUser,
+        summaryEditedByUser: parsed.summaryEditedByUser,
+        aiProvider: parsed.aiProvider,
+        aiGeneratedAt: parsed.aiGeneratedAt,
+        userIntent: parsed.userIntent,
+        intentPromptedAt: parsed.intentPromptedAt,
+        tags: parsed.tags,
+        // v0.4 Task 16 — 'archived' 는 NoteStatus 에서 제거됨. 기존 내보내기 파일의
+        // status=archived 를 읽을 때 completed 로 coerce (m008 과 동일 정책).
+        status: parsed.status === 'archived' ? 'completed' : parsed.status,
+        statusChangedAt: parsed.statusChangedAt,
+        moveReason: parsed.moveReason,
+        dueDate: parsed.dueDate,
+        dueDateEditedByUser: parsed.dueDateEditedByUser
+      });
+      if (r.status !== 'skipped') changedCount += 1;
+    }
+    return { changedCount };
+  }
+
   private async scanNotes(sourceDir: string): Promise<string[]> {
     const notesDir = join(sourceDir, 'notes');
     let entries: string[];

src/main/services/SettingsService.ts

@@ -13,7 +13,20 @@ const SettingsSchema = z.object({
   // true 로 fallback (기본 enabled). zod default 는 file 이 존재 + 키 부재일 때만 적용 —
   // load() 의 file-missing 분기에선 cache={} 라 isAiEnabled() 의 fallback 이 작동.
   ai_enabled: z.boolean().optional(),
-  onboarding_completed: z.boolean().optional()
+  onboarding_completed: z.boolean().optional(),
+  // v0.3.0 Cut E — 양방향 git sync 설정. 모두 optional — 미구성 시 sync 비활성.
+  sync_repo_url: z.string().nullable().optional(),
+  sync_auto_enabled: z.boolean().optional(),
+  sync_interval_min: z.number().int().min(5).optional(),
+  // v0.3.1 Cut F
+  vision_model: z.string().nullable().optional(),
+  vision_capable_cache: z.array(z.string()).optional(),
+  vision_cache_at: z.string().optional(),
+  // v0.4 Task 11 — promotion candidate 영속화 + sidebar 레이아웃.
+  promotion_dismissed_tags: z.array(z.string()).optional(),
+  promotion_snoozed_until_ms: z.number().int().optional(),
+  sidebar_visible: z.boolean().optional(),
+  sidebar_width: z.number().int().min(180).max(400).optional()
 }).strict();
 
 export type Settings = z.infer<typeof SettingsSchema>;
@@ -81,6 +94,116 @@ export class SettingsService {
     await this.persist(next);
   }
 
+  /**
+   * v0.3.0 Cut E — sync 저장소 URL. null/빈 문자열 = sync 비활성. 본 메서드는 값만 저장,
+   * git init/remote add 는 별도 호출자 (settings:configure-sync IPC) 가 담당.
+   */
+  async getSyncRepoUrl(): Promise<string | null> {
+    const s = await this.load();
+    return s.sync_repo_url ?? null;
+  }
+
+  async setSyncRepoUrl(value: string | null): Promise<void> {
+    const current = await this.load();
+    const next: Settings = { ...current, sync_repo_url: value };
+    await this.persist(next);
+  }
+
+  /** v0.3.0 Cut E — 자동 주기 sync 활성. configured 일 때만 의미 있음. 기본 true. */
+  async isAutoSyncEnabled(): Promise<boolean> {
+    const s = await this.load();
+    return s.sync_auto_enabled ?? true;
+  }
+
+  async setAutoSyncEnabled(value: boolean): Promise<void> {
+    const current = await this.load();
+    const next: Settings = { ...current, sync_auto_enabled: value };
+    await this.persist(next);
+  }
+
+  /** v0.3.0 Cut E — 자동 주기 sync interval (분). 기본 30, min 5. */
+  async getSyncIntervalMin(): Promise<number> {
+    const s = await this.load();
+    return s.sync_interval_min ?? 30;
+  }
+
+  async setSyncIntervalMin(value: number): Promise<void> {
+    if (!Number.isInteger(value) || value < 5) {
+      throw new Error(`sync_interval_min must be an integer >= 5 (got ${value})`);
+    }
+    const current = await this.load();
+    const next: Settings = { ...current, sync_interval_min: value };
+    await this.persist(next);
+  }
+
+  /** v0.3.1 Cut F — 선택된 vision model. null = 미선택. */
+  async getVisionModel(): Promise<string | null> {
+    const s = await this.load();
+    return s.vision_model ?? null;
+  }
+
+  async setVisionModel(value: string | null): Promise<void> {
+    const current = await this.load();
+    const next: Settings = { ...current, vision_model: value };
+    await this.persist(next);
+  }
+
+  /** v0.3.1 Cut F — /api/tags 조회 결과 캐시. 기본 빈 배열 + null timestamp. */
+  async getVisionCapableCache(): Promise<{ models: string[]; at: string | null }> {
+    const s = await this.load();
+    return { models: s.vision_capable_cache ?? [], at: s.vision_cache_at ?? null };
+  }
+
+  async setVisionCapableCache(models: string[], now: Date): Promise<void> {
+    const current = await this.load();
+    const next: Settings = { ...current, vision_capable_cache: models, vision_cache_at: now.toISOString() };
+    await this.persist(next);
+  }
+
+  // v0.4 Task 11 — promotion candidate 영속화.
+  async getPromotionDismissedTags(): Promise<string[]> {
+    const s = await this.load();
+    return s.promotion_dismissed_tags ?? [];
+  }
+
+  async addPromotionDismissedTag(tag: string): Promise<void> {
+    const s = await this.load();
+    const list = new Set(s.promotion_dismissed_tags ?? []);
+    list.add(tag);
+    await this.persist({ ...s, promotion_dismissed_tags: [...list] });
+  }
+
+  async getPromotionSnoozeUntil(): Promise<number> {
+    const s = await this.load();
+    return s.promotion_snoozed_until_ms ?? 0;
+  }
+
+  async setPromotionSnoozeUntil(ms: number): Promise<void> {
+    const s = await this.load();
+    await this.persist({ ...s, promotion_snoozed_until_ms: ms });
+  }
+
+  // v0.4 Task 15 — sidebar 레이아웃 영속화.
+  async getSidebarVisible(): Promise<boolean> {
+    const s = await this.load();
+    return s.sidebar_visible ?? true;
+  }
+
+  async setSidebarVisible(v: boolean): Promise<void> {
+    const s = await this.load();
+    await this.persist({ ...s, sidebar_visible: v });
+  }
+
+  async getSidebarWidth(): Promise<number> {
+    const s = await this.load();
+    return s.sidebar_width ?? 240;
+  }
+
+  async setSidebarWidth(v: number): Promise<void> {
+    const s = await this.load();
+    await this.persist({ ...s, sidebar_width: v });
+  }
+
   private async persist(next: Settings): Promise<void> {
     await mkdir(dirname(this.filePath), { recursive: true });
     const tmpPath = this.filePath + '.tmp';

src/main/services/SyncService.ts

@@ -1,22 +1,41 @@
 import { join } from 'node:path';
 import { mkdir } from 'node:fs/promises';
 import type { ExportService } from './ExportService.js';
+import type { ImportService } from './ImportService.js';
 import { GitClient } from './GitClient.js';
 
+/**
+ * Cut E final review fix: 'noteId' was misleading — F5 export filenames are
+ * `<date>-<id8>-<slug>.md` (composeFilename), not `<uuid>.md`. The git checkout /
+ * resolve operations use the FULL relative path (e.g., `notes/2026-05-09-abc12345-회의.md`).
+ * `path` matches what we actually pass to `git checkout --ours/theirs`.
+ */
+export interface SyncConflict {
+  path: string;
+  localText: string;
+  remoteText: string;
+}
+
 export interface SyncStatus {
   ok: boolean;
-  reason?: string;          // why the sync was skipped or failed
-  changed?: boolean;        // true if a new commit was created
-  sha?: string | null;
+  reason?: string;
+  changed?: boolean;
+  localSha?: string | null;
   pushed?: boolean;
+  importedCount?: number;
+  conflicts?: SyncConflict[];
 }
 
 export class SyncService {
   private syncDir: string;
+  private lastConflicts: SyncConflict[] = [];
+  private lastResult: SyncStatus | null = null;
+  private lastAt: string | null = null;
 
   constructor(
     private profileDir: string,
     private exportSvc: ExportService,
+    private importSvc: ImportService,
     private now: () => Date = () => new Date()
   ) {
     this.syncDir = join(profileDir, 'sync');
@@ -33,31 +52,151 @@ export class SyncService {
     return true;
   }
 
+  getLastStatus(): { lastAt: string | null; lastResult: SyncStatus | null } {
+    return { lastAt: this.lastAt, lastResult: this.lastResult };
+  }
+
+  listConflicts(): SyncConflict[] {
+    return this.lastConflicts;
+  }
+
   async sync(): Promise<SyncStatus> {
-    if (!(await this.isConfigured())) {
-      return { ok: false, reason: 'not_configured' };
+    const result = await this.runSync();
+    this.lastResult = result;
+    this.lastAt = this.now().toISOString();
+    if (result.reason === 'conflict' && result.conflicts) {
+      this.lastConflicts = result.conflicts;
+    } else if (result.ok) {
+      this.lastConflicts = [];
     }
-    // 1. Re-export the full tree into syncDir (idempotent).
+    return result;
+  }
+
+  /**
+   * v0.3.0 Cut E — conflict 해결. local/remote 2 choice (both deferred to v0.3.1+).
+   * 사용자가 ConflictModal 에서 선택 → IPC → 본 메서드. 각 conflict 의 path 별 호출.
+   *
+   * - 'local' = 내 것 사용 (origin 변경 폐기) → git checkout --ours
+   * - 'remote' = 원격 사용 → git checkout --theirs + applySyncFromDir (local DB 갱신)
+   *
+   * 모든 conflict 해결 후 rebase --continue 가 성공 → push.
+   * UI 가 여러 conflict 를 loop 호출하면 마지막 호출에서 push 까지 완료.
+   *
+   * Cut E final review fix: 파라미터를 path 로 변경 (옛 noteId 는 export filename slug,
+   * UUID 아님 — 혼동 회피).
+   */
+  async resolveConflict(
+    path: string,
+    choice: 'local' | 'remote'
+  ): Promise<{ ok: true } | { ok: false; reason: string }> {
+    const git = new GitClient(this.syncDir);
+    const flag = choice === 'local' ? '--ours' : '--theirs';
+
+    const checkout = await git.run(['checkout', flag, path]);
+    if (checkout.exitCode !== 0) {
+      return { ok: false, reason: `checkout failed: ${checkout.stderr}` };
+    }
+
+    await git.addAll();
+
+    const cont = await git.run(['rebase', '--continue']);
+    if (cont.exitCode !== 0) {
+      // Likely other unresolved files — UI will call resolveConflict for them.
+      return { ok: false, reason: `rebase --continue failed: ${cont.stderr}` };
+    }
+
+    if (choice === 'remote') {
+      try {
+        await this.importSvc.applySyncFromDir(this.syncDir);
+      } catch (e) {
+        return { ok: false, reason: `re-import failed: ${(e as Error).message}` };
+      }
+    }
+
+    try {
+      await git.push();
+    } catch (e) {
+      return { ok: false, reason: `push failed: ${(e as Error).message}` };
+    }
+
+    // Remove this path from cached conflicts list
+    this.lastConflicts = this.lastConflicts.filter((c) => c.path !== path);
+
+    return { ok: true };
+  }
+
+  private async runSync(): Promise<SyncStatus> {
+    if (!(await this.isConfigured())) return { ok: false, reason: 'not_configured' };
+
+    const git = new GitClient(this.syncDir);
+
+    // 1. local export
     try {
       await mkdir(this.syncDir, { recursive: true });
       await this.exportSvc.export(this.syncDir, { includeMedia: true });
     } catch (e) {
       return { ok: false, reason: `export failed: ${(e as Error).message}` };
     }
-    // 2. git add + commit + push
-    const git = new GitClient(this.syncDir);
+
+    // 2. local commit (only if changed)
+    let localSha: string | null = null;
+    let localChanged = false;
     try {
       await git.addAll();
-      const ts = this.now().toISOString();
-      const message = `chore(notes): sync ${ts}`;
-      const commit = await git.commit(message);
-      if (!commit.changed) {
-        return { ok: true, changed: false, pushed: false };
+      localChanged = await git.hasUncommittedChanges();
+      if (localChanged) {
+        const c = await git.commit(`chore(notes): sync ${this.now().toISOString()}`);
+        localSha = c.sha;
       }
-      await git.push();
-      return { ok: true, changed: true, sha: commit.sha, pushed: true };
     } catch (e) {
-      return { ok: false, reason: (e as Error).message };
+      return { ok: false, reason: `local commit failed: ${(e as Error).message}` };
     }
+
+    // 3. fetch
+    const fetchR = await git.fetch();
+    if (fetchR.exitCode !== 0) return { ok: false, reason: `fetch failed: ${fetchR.stderr}` };
+
+    // 4. rebase — skip if origin/main doesn't exist yet (first-push, empty remote)
+    const hasOriginMain = await git.refExists('origin/main');
+    if (hasOriginMain) {
+      const rebaseR = await git.rebaseOnto('origin/main');
+      if (rebaseR.exitCode !== 0) {
+        const files = await git.listConflicts();
+        // Cut E final review fix — populate localText/remoteText from rebase index
+        // BEFORE aborting. `git show :2:<path>` = ours (local during rebase),
+        // `:3:<path>` = theirs (remote being applied). UI shows side-by-side diff.
+        const conflicts: SyncConflict[] = [];
+        for (const path of files) {
+          const ours = await git.run(['show', `:2:${path}`]);
+          const theirs = await git.run(['show', `:3:${path}`]);
+          conflicts.push({
+            path,
+            localText: ours.exitCode === 0 ? ours.stdout : '',
+            remoteText: theirs.exitCode === 0 ? theirs.stdout : ''
+          });
+        }
+        await git.rebaseAbort();
+        return { ok: false, reason: 'conflict', conflicts };
+      }
+    }
+
+    // 5. re-import
+    let importedCount = 0;
+    try {
+      const r = await this.importSvc.applySyncFromDir(this.syncDir);
+      importedCount = r.changedCount;
+    } catch (e) {
+      return { ok: false, reason: `re-import failed: ${(e as Error).message}` };
+    }
+
+    // 6. push
+    try {
+      await git.push();
+    } catch (e) {
+      return { ok: false, reason: `push failed: ${(e as Error).message}` };
+    }
+
+    return { ok: true, changed: localChanged || importedCount > 0, localSha, importedCount, pushed: true };
   }
+
 }

src/main/services/SyncTimer.ts

@@ -0,0 +1,49 @@
+import type { SyncService } from './SyncService.js';
+import type { SettingsService } from './SettingsService.js';
+
+/**
+ * v0.3.0 Cut E — 자동 주기 sync timer.
+ *
+ * - start: settings 의 auto enabled + repo URL 모두 갖춰져야 시작
+ * - reconfigure: settings 변경 시 stop + start (새 interval 적용)
+ * - stop: clearInterval (idempotent)
+ *
+ * sync 결과는 무시 (interval mode = silent). conflict 발생 시 다음 manual sync /
+ * 충돌 UI 진입 시 처리됨 — 사용자가 settings 페이지의 SyncSection 에서 확인 가능.
+ */
+export class SyncTimer {
+  private handle: NodeJS.Timeout | null = null;
+
+  constructor(
+    private syncSvc: SyncService,
+    private settings: SettingsService
+  ) {}
+
+  async start(): Promise<void> {
+    if (this.handle !== null) return;  // idempotent
+    const enabled = await this.settings.isAutoSyncEnabled();
+    if (!enabled) return;
+    const url = await this.settings.getSyncRepoUrl();
+    if (url === null || url.trim().length === 0) return;
+    const intervalMin = await this.settings.getSyncIntervalMin();
+    const ms = Math.max(5, intervalMin) * 60 * 1000;
+    this.handle = setInterval(() => {
+      void this.syncSvc.sync().catch(() => {
+        // silent — interval mode 의 실패는 다음 attempt 또는 사용자 manual 호출이 처리
+      });
+    }, ms);
+  }
+
+  stop(): void {
+    if (this.handle !== null) {
+      clearInterval(this.handle);
+      this.handle = null;
+    }
+  }
+
+  /** settings 변경 시 호출 — 현재 interval stop 후 새 값으로 start. */
+  async reconfigure(): Promise<void> {
+    this.stop();
+    await this.start();
+  }
+}

src/main/services/VisionDetect.ts

@@ -0,0 +1,47 @@
+import type { SettingsService } from './SettingsService.js';
+
+// v0.3.1 Cut F final fix — gemma 시리즈 default 정정. 본인 dogfood 환경 = gemma4:e4b
+// (텍스트). vision 변종은 gemma3 (현재 vision-capable) 또는 gemma4 (향후 출시 시).
+// 양 family 모두 hint 에 포함 — capability detection 이 future-proof.
+const VISION_FAMILIES = new Set(['gemma3', 'gemma4', 'llava', 'llama3.2-vision', 'minicpm-v', 'pixtral']);
+const VISION_NAME_HINTS = ['vision', 'vl', 'multimodal', 'gemma3', 'gemma4'];
+
+export interface OllamaModel {
+  name: string;
+  details?: { family?: string; families?: string[] };
+}
+
+export function isVisionCapable(model: OllamaModel): boolean {
+  if (model.details?.family && VISION_FAMILIES.has(model.details.family)) return true;
+  if (model.details?.families?.some((f) => VISION_FAMILIES.has(f))) return true;
+  const lower = model.name.toLowerCase();
+  return VISION_NAME_HINTS.some((h) => lower.includes(h));
+}
+
+export interface RefreshDeps {
+  settings: SettingsService;
+  endpoint: string;
+  now?: () => Date;
+  fetchImpl?: typeof fetch;
+}
+
+export async function refreshVisionCache(
+  deps: RefreshDeps
+): Promise<{ ok: true; models: string[] } | { ok: false; reason: string }> {
+  if (!(await deps.settings.isAiEnabled())) {
+    return { ok: false, reason: 'ai_disabled' };
+  }
+  const fetchFn = deps.fetchImpl ?? fetch;
+  let body: { models?: OllamaModel[] };
+  try {
+    const r = await fetchFn(`${deps.endpoint}/api/tags`);
+    if (!r.ok) return { ok: false, reason: `tags http ${r.status}` };
+    body = (await r.json()) as { models?: OllamaModel[] };
+  } catch (e) {
+    return { ok: false, reason: `unreachable: ${(e as Error).message}` };
+  }
+  const capable = (body.models ?? []).filter(isVisionCapable).map((m) => m.name);
+  const now = deps.now ? deps.now() : new Date();
+  await deps.settings.setVisionCapableCache(capable, now);
+  return { ok: true, models: capable };
+}

src/main/services/exportFormat.ts

@@ -29,6 +29,13 @@ export interface ExportNote {
   aiGeneratedAt: string | null;
   userIntent: string | null;
   intentPromptedAt: string | null;
+  // v0.3.0 Cut E — Cut B (status), Cut C (dueDate via m002), and dueDate user-edited flag
+  // need to round-trip through F5 export and Cut E sync.
+  status: 'active' | 'completed' | 'archived' | 'trashed';
+  statusChangedAt: string | null;
+  moveReason: string | null;
+  dueDate: string | null;
+  dueDateEditedByUser: boolean;
   tags: ExportNoteTag[];
   media: ExportNoteMedia[];
 }
@@ -155,6 +162,18 @@ export function composeFrontmatter(note: ExportNote): string {
     lines.push(`ai_generated_at: ${note.aiGeneratedAt}`);
   }
 
+  lines.push(`status: ${note.status}`);
+  if (note.statusChangedAt !== null) {
+    lines.push(`status_changed_at: ${note.statusChangedAt}`);
+  }
+  if (note.moveReason !== null) {
+    lines.push(`move_reason: ${formatScalar(note.moveReason)}`);
+  }
+  if (note.dueDate !== null) {
+    lines.push(`due_date: ${note.dueDate}`);
+    lines.push(`due_date_source: ${note.dueDateEditedByUser ? 'user' : 'ai'}`);
+  }
+
   if (note.media.length > 0) {
     lines.push('images:');
     for (const m of note.media) {
@@ -234,14 +253,15 @@ export function composeIndexJsonl(
 // ---------------------------------------------------------------------------
 
 export function composeManifest(input: {
-  exportedAt: string;
   noteCount: number;
   mediaCount: number;
 }): string {
+  // exported_at 필드 의도적 제외 — note 변경 없이도 git sync 가 매 호출마다
+  // timestamp 갱신 1줄 commit 을 만들어 history 노이즈와 불필요한 push 유발.
+  // import path 는 inkling_export_version 만 read 하므로 안전.
   return JSON.stringify(
     {
       inkling_export_version: 1,
-      exported_at: input.exportedAt,
       note_count: input.noteCount,
       media_count: input.mediaCount
     },

src/main/services/importFormat.ts

@@ -34,6 +34,13 @@ export interface ParsedNote {
   userIntent: string | null;
   intentPromptedAt: string | null;
   deletedAt: string | null;  // 신규 v0.2.3 #4
+  // v0.3.0 Cut E — round-trip status / due_date / move_reason from frontmatter.
+  // Default to 'active' / null / false when absent (older exports pre-Cut E).
+  status: 'active' | 'completed' | 'archived' | 'trashed';
+  statusChangedAt: string | null;
+  moveReason: string | null;
+  dueDate: string | null;
+  dueDateEditedByUser: boolean;
   tags: ParsedNoteTag[];
   images: ParsedNoteImage[];
   exportVersion: number;
@@ -335,6 +342,13 @@ export function parseExportNote(markdown: string): ParsedNote {
   const versionRaw = get('inkling_export_version');
   const exportVersion = versionRaw === null ? 0 : Number.parseInt(versionRaw, 10) || 0;
 
+  const statusRaw = get('status');
+  const validStatuses = ['active', 'completed', 'archived', 'trashed'] as const;
+  const status = (validStatuses as readonly string[]).includes(statusRaw ?? 'active')
+    ? ((statusRaw ?? 'active') as ParsedNote['status'])
+    : 'active';
+  const dueDateSource = get('due_date_source');
+
   return {
     id,
     createdAt,
@@ -349,6 +363,11 @@ export function parseExportNote(markdown: string): ParsedNote {
     userIntent: get('user_intent'),
     intentPromptedAt: get('intent_prompted_at'),
     deletedAt: get('deleted_at'),
+    status,
+    statusChangedAt: get('status_changed_at'),
+    moveReason: get('move_reason'),
+    dueDate: get('due_date'),
+    dueDateEditedByUser: dueDateSource === 'user',
     tags: fm.tags,
     images: fm.images,
     exportVersion

src/main/windows/inboxWindow.ts

@@ -11,16 +11,19 @@ export function getInboxWindow(): BrowserWindowType | null {
   return inboxWindow;
 }
 
-export function createInboxWindow(): BrowserWindowType {
+export function createInboxWindow(opts: { visible?: boolean } = {}): BrowserWindowType {
+  const visible = opts.visible ?? true;
   if (inboxWindow && !inboxWindow.isDestroyed()) {
-    inboxWindow.show();
-    inboxWindow.focus();
+    if (visible) {
+      inboxWindow.show();
+      inboxWindow.focus();
+    }
     return inboxWindow;
   }
 
   inboxWindow = new BrowserWindow({
-    width: 900,
-    height: 720,
+    width: 1440,
+    height: 900,
     show: false,
     webPreferences: {
       preload: join(__dirname, '../preload/index.js'),
@@ -43,6 +46,19 @@ export function createInboxWindow(): BrowserWindowType {
     }
   });
 
-  inboxWindow.once('ready-to-show', () => inboxWindow?.show());
+  inboxWindow.once('ready-to-show', () => {
+    if (visible) {
+      inboxWindow?.show();
+      return;
+    }
+    // macOS hidden autostart: regular NSWindow 를 NSApp 에 register 해야 dock running
+    // indicator (점) 가 표출된다. panel type 의 quickCapture 만 있으면 NSPanel 미인지 →
+    // dock 점이 안 보여 "앱이 안 떠 있는 것처럼" 보이는 버그. showInactive 로 focus 점유
+    // 없이 짧게 표출 후 즉시 hide — 사용자 화면 깜빡임 최소화.
+    if (process.platform === 'darwin') {
+      inboxWindow?.showInactive();
+      inboxWindow?.hide();
+    }
+  });
   return inboxWindow;
 }

src/main/windows/quickCaptureWindow.ts

@@ -16,23 +16,35 @@ export function createQuickCaptureWindow(): BrowserWindowType {
   const x = Math.round((primary.workArea.width - W) / 2 + primary.workArea.x);
   const y = Math.round((primary.workArea.height - H) / 3 + primary.workArea.y);
 
+  // v0.3.10 — macOS fullscreen Space 위에 quick capture 띄우기.
+  // 기본 BrowserWindow 는 첫 생성된 Space (홈 데스크탑) 에만 표시되므로
+  // 사용자가 다른 앱 fullscreen 중일 때 macOS 가 강제 Space 전환 → 사용자 경험 깨짐.
+  // 'panel' 타입 + 'screen-saver' level + visibleOnFullScreen 조합으로 현재 Space 위에 overlay.
+  const isMac = process.platform === 'darwin';
   win = new BrowserWindow({
     width: W, height: H, x, y,
     frame: false, show: false, alwaysOnTop: true,
     skipTaskbar: true, resizable: false,
+    ...(isMac ? { type: 'panel' as const } : {}),
     webPreferences: {
       preload: join(__dirname, '../preload/index.js'),
       contextIsolation: true, nodeIntegration: false, sandbox: false
     }
   });
 
+  if (isMac) {
+    // 'screen-saver' level — fullscreen app 위에 띄울 수 있는 가장 높은 level.
+    // visibleOnFullScreen: true — 현재 fullscreen Space 에 함께 표시 (Space 전환 안 함).
+    win.setAlwaysOnTop(true, 'screen-saver');
+    win.setVisibleOnAllWorkspaces(true, { visibleOnFullScreen: true });
+  }
+
   if (process.env.ELECTRON_RENDERER_URL) {
     win.loadURL(`${process.env.ELECTRON_RENDERER_URL}/quickcapture/index.html`);
   } else {
     win.loadFile(join(__dirname, '../renderer/quickcapture/index.html'));
   }
 
-  win.on('blur', () => { if (win?.isVisible()) win.hide(); });
   return win;
 }
 

src/preload/index.ts

@@ -8,7 +8,7 @@ const api: InklingApi = {
     hide: () => ipcRenderer.send('capture:hide')
   },
   inbox: {
-    listNotes: (opts) => ipcRenderer.invoke('inbox:list', opts),
+    listNotes: (opts: { limit: number; cursor?: string; notebookId?: string }) => ipcRenderer.invoke('inbox:list', opts),
     updateAiFields: (noteId, fields) =>
       ipcRenderer.invoke('inbox:updateAi', { noteId, fields }),
     setDueDate: (noteId, date) => ipcRenderer.invoke('inbox:setDueDate', { noteId, date }),
@@ -40,11 +40,13 @@ const api: InklingApi = {
     },
     retryAllFailed: () => ipcRenderer.invoke('inbox:retryAllFailed'),
     getFailedCount: () => ipcRenderer.invoke('inbox:failedCount'),
+    retryOneFailed: (id: string) => ipcRenderer.invoke('inbox:retry-one-failed', id),
+    cancelPending: (id: string) => ipcRenderer.invoke('inbox:cancel-pending', id),
     listRecallCandidate: () => ipcRenderer.invoke('inbox:listRecallCandidate'),
     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),
+    emitRecallShown: (id: string) => { ipcRenderer.send('inbox:emitRecallShown', id); },
+    emitRecallSnoozed: (id: string) => { ipcRenderer.send('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.
@@ -69,8 +71,9 @@ const api: InklingApi = {
     // v0.2.8 Cut A — 첨부 이미지를 OS 기본 뷰어로 열기 (Task 3).
     openMedia: (relPath: string) => ipcRenderer.invoke('inbox:open-media', relPath),
     // v0.2.9 Cut B Task 4 — status 별 list + counts.
+    // v0.4 — notebookId 옵션 pass-through. countsByStatus opts 추가.
     listByStatus: (status, opts) => ipcRenderer.invoke('inbox:list-by-status', status, opts ?? {}),
-    countsByStatus: () => ipcRenderer.invoke('inbox:counts-by-status'),
+    countsByStatus: (opts?: { notebookId?: string }) => ipcRenderer.invoke('inbox:counts-by-status', opts ?? {}),
     // v0.2.9 Cut B Task 8 — 4분기 status 전이 + AI 자동 분류 추천.
     setStatus: (id, status, reason) => ipcRenderer.invoke('inbox:set-status', id, status, reason),
     classifyStatus: (id, reason) => ipcRenderer.invoke('ai:classify-status', id, reason),
@@ -78,6 +81,9 @@ const api: InklingApi = {
     getSettings: () => ipcRenderer.invoke('settings:get'),
     setAiEnabled: (enabled: boolean) => ipcRenderer.invoke('settings:set-ai-enabled', enabled),
     setOnboardingCompleted: (completed: boolean) => ipcRenderer.invoke('settings:set-onboarding-completed', completed),
+    // v0.4 — Sidebar UI state 영속화
+    setSidebarVisible: (visible: boolean) => ipcRenderer.invoke('settings:set-sidebar-visible', visible),
+    setSidebarWidth: (width: number) => ipcRenderer.invoke('settings:set-sidebar-width', width),
     // v0.2.9 Cut B Task 16 — disabled 메모 재투입 + count.
     enqueueDisabled: () => ipcRenderer.invoke('inbox:enqueue-disabled'),
     getDisabledCount: () => ipcRenderer.invoke('inbox:get-disabled-count'),
@@ -85,6 +91,41 @@ const api: InklingApi = {
     updateRawText: (noteId: string, newText: string) => ipcRenderer.invoke('inbox:update-raw-text', noteId, newText),
     listRevisions: (noteId: string) => ipcRenderer.invoke('inbox:list-revisions', noteId),
     restoreRevision: (noteId: string, revId: number) => ipcRenderer.invoke('inbox:restore-revision', noteId, revId),
+    // v0.2.11 Cut D — search + 회고 aggregate.
+    // v0.4 — notebookId 옵션 pass-through.
+    search: (query, opts) => ipcRenderer.invoke('inbox:search', query, opts ?? {}),
+    reviewAggregate: (period) => ipcRenderer.invoke('inbox:review-aggregate', period),
+    // v0.3.0 Cut E — 양방향 sync.
+    configureSync: (url: string | null) => ipcRenderer.invoke('settings:configure-sync', url),
+    testSyncConnection: () => ipcRenderer.invoke('settings:test-sync-connection'),
+    listConflicts: () => ipcRenderer.invoke('sync:list-conflicts'),
+    resolveConflict: (path: string, choice: 'local' | 'remote') =>
+      ipcRenderer.invoke('sync:resolve-conflict', path, choice),
+    getSyncStatus: () => ipcRenderer.invoke('sync:get-status'),
+    setSyncAutoEnabled: (value: boolean) => ipcRenderer.invoke('settings:set-sync-auto-enabled', value),
+    setSyncIntervalMin: (value: number) => ipcRenderer.invoke('settings:set-sync-interval-min', value),
+    // v0.3.1 Cut F — vision capability + 모델 선택
+    getVisionModels: () => ipcRenderer.invoke('settings:get-vision-models'),
+    setVisionModel: (value: string | null) => ipcRenderer.invoke('settings:set-vision-model', value),
+    refreshVisionCache: () => ipcRenderer.invoke('settings:refresh-vision-cache'),
+    // v0.4 T4 — AI batch classify (단일 prompt).
+    batchClassifyDefault: () => ipcRenderer.invoke('inbox:batch-classify-default'),
+    // v0.4 Task 11 — promotion candidates + dismissed/snoozed 영속화.
+    listPromotionCandidates: () => ipcRenderer.invoke('inbox:list-promotion-candidates'),
+    getPromotionDismissedTags: () => ipcRenderer.invoke('inbox:get-promotion-dismissed-tags'),
+    addPromotionDismissedTag: (tag: string) => ipcRenderer.invoke('inbox:add-promotion-dismissed-tag', tag),
+    getPromotionSnoozeUntil: () => ipcRenderer.invoke('inbox:get-promotion-snoozed-until'),
+    setPromotionSnoozeUntil: (ms: number) => ipcRenderer.invoke('inbox:set-promotion-snoozed-until', ms),
+  },
+  // v0.4 — notebook CRUD IPC
+  notebook: {
+    list: () => ipcRenderer.invoke('notebook:list'),
+    create: (input: { name: string; color?: string }) => ipcRenderer.invoke('notebook:create', input),
+    rename: (id: string, name: string) => ipcRenderer.invoke('notebook:rename', id, name),
+    setColor: (id: string, color: string | null) => ipcRenderer.invoke('notebook:set-color', id, color),
+    delete: (id: string) => ipcRenderer.invoke('notebook:delete', id),
+    moveNote: (noteId: string, notebookId: string) => ipcRenderer.invoke('notebook:move-note', noteId, notebookId),
+    reorder: (id: string, direction: 'up' | 'down') => ipcRenderer.invoke('notebook:reorder', id, direction)
   }
 };
 

src/renderer/inbox/App.tsx

@@ -14,6 +14,15 @@ import { FailedBanner } from './components/FailedBanner.js';
 import { RecallBanner } from './components/RecallBanner.js';
 import { SettingsPage } from './components/SettingsPage.js';
 import { OnboardingWizard } from './components/OnboardingWizard.js';
+import { SearchBox } from './components/SearchBox.js';
+import { ReviewView } from './components/ReviewView.js';
+import { Sidebar } from './components/Sidebar.js';
+import { PromotionBanner } from './components/PromotionBanner.js';
+import { BatchMoveModal } from './components/BatchMoveModal.js';
+import type { InboxView } from './store.js';
+
+// QuickCapture 단축키 modifier — macOS 는 Cmd, 그 외는 Ctrl.
+const MOD_KEY = /Mac/i.test(navigator.platform) ? 'Cmd' : 'Ctrl';
 
 export function App(): React.ReactElement {
   const {
@@ -28,6 +37,11 @@ export function App(): React.ReactElement {
   const view = useInbox((s) => s.view);
   const counts = useInbox((s) => s.counts);
   const setView = useInbox((s) => s.setView);
+  const searchResults = useInbox((s) => s.searchResults);
+  const selectedNotebookId = useInbox((s) => s.selectedNotebookId);
+  const notebooks = useInbox((s) => s.notebooks);
+  const runBatchClassify = useInbox((s) => s.runBatchClassify);
+  const batchClassifying = useInbox((s) => s.batchClassifying);
   const [recoveryDismissed, setRecoveryDismissed] = useState(isRecoveryDismissedToday());
   // v0.2.9 Cut B Task 12 — 첫 launch onboarding 분기. null = 로딩, true = 표시, false = 미표시.
   const [showOnboarding, setShowOnboarding] = useState<boolean | null>(null);
@@ -44,6 +58,23 @@ export function App(): React.ReactElement {
     })();
   }, []);
 
+  useEffect(() => {
+    void useInbox.getState().loadNotebooks();
+    void useInbox.getState().loadPromotionCandidates();
+  }, []);
+
+  useEffect(() => {
+    const isMac = /Mac/i.test(navigator.platform);
+    const handler = (e: KeyboardEvent) => {
+      if (e.key === 'b' && (isMac ? e.metaKey : e.ctrlKey) && !e.shiftKey && !e.altKey) {
+        e.preventDefault();
+        useInbox.getState().toggleSidebar();
+      }
+    };
+    window.addEventListener('keydown', handler);
+    return () => window.removeEventListener('keydown', handler);
+  }, []);
+
   useEffect(() => {
     void loadInitial();
     const unsubNote = inboxApi.onNoteUpdated((note) => {
@@ -64,13 +95,21 @@ export function App(): React.ReactElement {
     // deps array 에 추가 불필요. mount 시 1회 구독 + unmount 시 해제.
   }, [loadInitial, refreshMeta, upsertNote]);
 
+  // v0.4 T5 — default notebook(첫 번째) 선택 시 "AI 정리하기" 버튼 노출 조건.
+  const isDefaultNotebook = notebooks.length > 0 && selectedNotebookId === notebooks[0]?.id;
+
   if (showOnboarding === null) return <></>;
   if (showOnboarding) return <OnboardingWizard onClose={() => setShowOnboarding(false)} />;
 
+  if (view === 'review-daily') return <ReviewView period="daily" />;
+  if (view === 'review-weekly') return <ReviewView period="weekly" />;
+  if (view === 'review-monthly') return <ReviewView period="monthly" />;
+
   if (showSettings) return <SettingsPage />;
 
   const showRecovery = continuity.showRecoveryToast && !recoveryDismissed;
   const filtered = selectFilteredNotes({ notes, tagFilter });
+  const displayed = searchResults !== null ? searchResults : filtered;
 
   const tabBtnStyle = (active: boolean): React.CSSProperties => ({
     background: active ? '#0a4b80' : 'transparent',
@@ -83,28 +122,70 @@ export function App(): React.ReactElement {
   });
 
   return (
-    <>
+    <div style={{ display: 'flex', height: '100vh' }}>
+      <Sidebar />
+      <main style={{ flex: 1, overflowY: 'auto' }}>
       <div className="header">
+        <button
+          onClick={() => useInbox.getState().toggleSidebar()}
+          aria-label="사이드바 토글"
+          title="사이드바 토글 (Cmd/Ctrl+B)"
+          style={{
+            background: 'none', border: 'none', cursor: 'pointer',
+            fontSize: 18, padding: '0 8px 0 0', color: '#444', lineHeight: 1
+          }}
+        >
+          ☰
+        </button>
         <h1 style={{ fontSize: 18, margin: 0 }}>Inkling</h1>
         <div style={{ display: 'flex', gap: 6, marginLeft: 12 }}>
           {(
             [
               { key: 'inbox', label: 'Inbox', count: counts.active },
               { key: 'completed', label: '완료', count: counts.completed },
-              { key: 'archived', label: '보관', count: counts.archived },
               { key: 'trash', label: '휴지통', count: counts.trashed }
             ] as const
           ).map((t) => (
             <button
               key={t.key}
+              type="button"
+              role="tab"
+              aria-selected={view === t.key}
               onClick={() => setView(t.key)}
-              aria-pressed={view === t.key}
               style={tabBtnStyle(view === t.key)}
             >
               {t.label}({t.count})
             </button>
           ))}
         </div>
+        {view === 'inbox' && isDefaultNotebook && notebooks.length > 1 && (
+          <button
+            onClick={() => { void runBatchClassify(); }}
+            disabled={batchClassifying}
+            style={{
+              background: '#5a3a8c', color: '#fff', border: 'none', borderRadius: 4,
+              padding: '4px 10px', fontSize: 11, cursor: batchClassifying ? 'not-allowed' : 'pointer',
+              marginLeft: 8
+            }}
+          >
+            {batchClassifying ? '🪄 분석 중…' : '🪄 AI 정리하기'}
+          </button>
+        )}
+        <select
+          aria-label="회고 기간"
+          value={view.startsWith('review-') ? view.replace('review-', '') : ''}
+          onChange={(e) => {
+            const v = e.target.value;
+            if (v === 'daily' || v === 'weekly' || v === 'monthly') setView(`review-${v}` as InboxView);
+          }}
+          style={{ marginLeft: 8, fontSize: 12, padding: '4px 6px', border: '1px solid #0a4b80', borderRadius: 4, color: '#0a4b80', background: 'transparent' }}
+        >
+          <option value="">📅 회고…</option>
+          <option value="daily">일간</option>
+          <option value="weekly">주간</option>
+          <option value="monthly">월간</option>
+        </select>
+        <SearchBox />
         <div style={{ display: 'flex', flexDirection: 'column', alignItems: 'flex-end', gap: 2, marginLeft: 'auto' }}>
           <ContinuityBadge />
           <IdentityCounter />
@@ -124,18 +205,25 @@ export function App(): React.ReactElement {
           ⚙
         </button>
       </div>
-      <main className="main">
+      <div className="main">
         {!showTrash && (
           <>
-            <OllamaBanner onOpenSettings={() => setShowSettings(true)} />
-            <RecoveryToast
-              show={showRecovery}
-              onDismiss={() => { markRecoveryDismissed(); setRecoveryDismissed(true); }}
-            />
-            <PendingBanner />
-            <FailedBanner />
-            <ExpiryBanner />
-            <RecallBanner />
+            {/* AI/만료/회상 배너는 active 노트 컨텍스트 — inbox 탭에서만 노출.
+                completed/archived 에서는 무관 컨텐츠라 숨김. */}
+            {view === 'inbox' && (
+              <>
+                <OllamaBanner onOpenSettings={() => setShowSettings(true)} />
+                <RecoveryToast
+                  show={showRecovery}
+                  onDismiss={() => { markRecoveryDismissed(); setRecoveryDismissed(true); }}
+                />
+                <PendingBanner />
+                <FailedBanner />
+                <ExpiryBanner />
+                <RecallBanner />
+                <PromotionBanner />
+              </>
+            )}
             {tagFilter !== null && (
               <div style={{
                 background: '#eaf3ff', color: '#0a4b80', padding: '6px 12px',
@@ -155,12 +243,14 @@ export function App(): React.ReactElement {
             )}
             {loading && notes.length === 0 ? (
               <div className="empty">불러오는 중…</div>
+            ) : searchResults !== null && displayed.length === 0 ? (
+              <div className="empty">검색 결과가 없습니다.</div>
             ) : notes.length === 0 ? (
-              <div className="empty">머릿속에 떠다니는 한 줄을 적어보세요. <code>Ctrl+Shift+J</code></div>
-            ) : filtered.length === 0 ? (
+              <div className="empty">머릿속에 떠다니는 한 줄을 적어보세요. <code>{MOD_KEY}+Shift+J</code></div>
+            ) : displayed.length === 0 ? (
               <div className="empty">이 태그의 노트가 없습니다.</div>
             ) : (
-              filtered.map((n) => (
+              displayed.map((n) => (
                 <NoteCard
                   key={n.id} note={n} mode="inbox"
                   onDeleted={() => removeNote(n.id)}
@@ -200,8 +290,10 @@ export function App(): React.ReactElement {
             )}
           </>
         )}
-      </main>
+      </div>
       <TagUndoToast />
-    </>
+      </main>
+      <BatchMoveModal />
+    </div>
   );
 }

src/renderer/inbox/api.ts

@@ -1,2 +1,3 @@
-import type { InboxApi } from '@shared/types';
+import type { InboxApi, NotebookApi } from '@shared/types';
 export const inboxApi: InboxApi = window.inkling.inbox;
+export const notebookApi: NotebookApi = window.inkling.notebook;

src/renderer/inbox/components/BatchMoveModal.tsx

@@ -0,0 +1,98 @@
+import React, { useEffect, useState } from 'react';
+import { useInbox } from '../store.js';
+
+export function BatchMoveModal(): React.ReactElement | null {
+  const result = useInbox((s) => s.batchClassifyResult);
+  const clear = useInbox((s) => s.clearBatchClassify);
+  const accept = useInbox((s) => s.acceptBatchAssignments);
+  const notes = useInbox((s) => s.notes);
+  const [selectedIds, setSelectedIds] = useState<Set<string>>(new Set());
+
+  // result 변할 때 → 매칭된 (notebookId != null) noteId 모두 default 로 select
+  useEffect(() => {
+    if (result === null) return;
+    const ids = new Set<string>();
+    for (const a of result.assignments) {
+      if (a.notebookId !== null) ids.add(a.noteId);
+    }
+    setSelectedIds(ids);
+  }, [result]);
+
+  if (result === null) return null;
+
+  const actionable = result.assignments.filter((a) => a.notebookId !== null);
+
+  function toggle(noteId: string) {
+    setSelectedIds((prev) => {
+      const n = new Set(prev);
+      if (n.has(noteId)) n.delete(noteId);
+      else n.add(noteId);
+      return n;
+    });
+  }
+
+  function findNote(id: string): string {
+    const n = notes.find((nn) => nn.id === id);
+    return n?.aiTitle ?? n?.rawText.slice(0, 60) ?? '(노트)';
+  }
+
+  async function onConfirm() {
+    const accepted = actionable
+      .filter((a) => selectedIds.has(a.noteId) && a.notebookId !== null)
+      .map((a) => ({ noteId: a.noteId, notebookId: a.notebookId! }));
+    await accept(accepted);
+  }
+
+  return (
+    <div
+      onClick={clear}
+      style={{ position: 'fixed', inset: 0, background: 'rgba(0,0,0,0.4)', display: 'flex', alignItems: 'center', justifyContent: 'center', zIndex: 130 }}
+    >
+      <div
+        onClick={(e) => e.stopPropagation()}
+        style={{ background: '#fff', padding: 20, borderRadius: 8, width: 560, maxHeight: '80vh', overflow: 'auto' }}
+      >
+        <h3 style={{ margin: '0 0 12px 0', fontSize: 15 }}>AI 분류 제안</h3>
+        {actionable.length === 0 ? (
+          <p style={{ fontSize: 13, color: '#666' }}>
+            현재 분류할 만한 노트를 찾지 못했어요. 노트북을 더 만들거나 노트가 누적된 뒤 다시 시도해보세요.
+          </p>
+        ) : (
+          <>
+            <p style={{ fontSize: 12, color: '#666', marginBottom: 10 }}>
+              체크된 노트만 이동합니다. ({selectedIds.size}/{actionable.length})
+            </p>
+            <div style={{ maxHeight: '50vh', overflow: 'auto', border: '1px solid #eee', borderRadius: 4 }}>
+              {actionable.map((a) => (
+                <label
+                  key={a.noteId}
+                  style={{ display: 'flex', alignItems: 'center', gap: 8, padding: '6px 10px', borderBottom: '1px solid #f0f0f0', cursor: 'pointer', fontSize: 12 }}
+                >
+                  <input
+                    type="checkbox"
+                    checked={selectedIds.has(a.noteId)}
+                    onChange={() => toggle(a.noteId)}
+                  />
+                  <span style={{ flex: 1, overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }}>
+                    {findNote(a.noteId)}
+                  </span>
+                  <span style={{ color: '#0a4b80', fontSize: 11 }}>→ {a.notebookName}</span>
+                </label>
+              ))}
+            </div>
+          </>
+        )}
+        <div style={{ display: 'flex', gap: 8, justifyContent: 'flex-end', marginTop: 14 }}>
+          <button onClick={clear} style={{ padding: '5px 12px', fontSize: 12 }}>취소</button>
+          <button
+            onClick={() => { void onConfirm(); }}
+            disabled={selectedIds.size === 0}
+            style={{ padding: '5px 12px', fontSize: 12, background: '#0a4b80', color: '#fff', border: 'none', borderRadius: 4, cursor: selectedIds.size === 0 ? 'not-allowed' : 'pointer', opacity: selectedIds.size === 0 ? 0.5 : 1 }}
+          >
+            {selectedIds.size}건 이동
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}

src/renderer/inbox/components/ConflictModal.tsx

@@ -0,0 +1,135 @@
+import React, { useEffect, useState } from 'react';
+import type { SyncConflict } from '@shared/types';
+import { inboxApi } from '../api.js';
+import type { SyncHelpAnchor } from './SyncHelpModal.js';
+
+interface Props {
+  onClose: () => void;
+  onResolved: () => void;
+  onOpenHelp?: (anchor: SyncHelpAnchor) => void;
+}
+
+const overlayStyle: React.CSSProperties = {
+  position: 'fixed', top: 0, left: 0, width: '100vw', height: '100vh',
+  background: 'rgba(0,0,0,0.4)', display: 'flex', alignItems: 'center',
+  justifyContent: 'center', zIndex: 100
+};
+
+const modalStyle: React.CSSProperties = {
+  background: '#fff', borderRadius: 8, padding: 20, width: 600,
+  maxHeight: '70vh', overflow: 'auto', boxShadow: '0 4px 16px rgba(0,0,0,0.2)'
+};
+
+const rowStyle: React.CSSProperties = {
+  border: '1px solid #eee', borderRadius: 6, padding: 10, marginTop: 8
+};
+
+export function ConflictModal({ onClose, onResolved, onOpenHelp }: Props): React.ReactElement {
+  const [conflicts, setConflicts] = useState<SyncConflict[]>([]);
+  const [busy, setBusy] = useState<string | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    let cancelled = false;
+    void (async () => {
+      const c = await inboxApi.listConflicts();
+      if (!cancelled) setConflicts(c);
+    })();
+    return () => { cancelled = true; };
+  }, []);
+
+  // Escape key 로 닫기.
+  useEffect(() => {
+    function onKey(e: KeyboardEvent) {
+      if (e.key === 'Escape') onClose();
+    }
+    document.addEventListener('keydown', onKey);
+    return () => document.removeEventListener('keydown', onKey);
+  }, [onClose]);
+
+  async function onChoose(path: string, choice: 'local' | 'remote') {
+    setBusy(path);
+    setError(null);
+    const r = await inboxApi.resolveConflict(path, choice);
+    setBusy(null);
+    if (!r.ok) {
+      setError(`해결 실패: ${r.reason}`);
+      return;
+    }
+    const next = conflicts.filter((c) => c.path !== path);
+    setConflicts(next);
+    if (next.length === 0) {
+      onResolved();
+      onClose();
+    }
+  }
+
+  return (
+    <div style={overlayStyle} onClick={onClose}>
+      <div style={modalStyle} onClick={(e) => e.stopPropagation()}>
+        <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>
+          <h3 style={{ margin: 0, fontSize: 16 }}>충돌 ({conflicts.length}건)</h3>
+          <button onClick={onClose} aria-label="닫기" style={{ background: 'none', border: 'none', fontSize: 18, cursor: 'pointer', color: '#888' }}>×</button>
+        </div>
+        {error !== null && <div style={{ marginTop: 10, fontSize: 12, color: '#c93030' }}>{error}</div>}
+        {conflicts.map((c) => (
+          <div key={c.path} style={rowStyle}>
+            <div style={{ fontSize: 12, color: '#888', marginBottom: 6 }}>{c.path}</div>
+            <div style={{ display: 'flex', gap: 12 }}>
+              <div style={{ flex: 1 }}>
+                <div style={{ fontSize: 11, color: '#666', marginBottom: 4 }}>내 기기</div>
+                <pre style={preStyle()}>{c.localText || '(미리보기 없음)'}</pre>
+              </div>
+              <div style={{ flex: 1 }}>
+                <div style={{ fontSize: 11, color: '#666', marginBottom: 4 }}>다른 기기</div>
+                <pre style={preStyle()}>{c.remoteText || '(미리보기 없음)'}</pre>
+              </div>
+            </div>
+            <div style={{ marginTop: 8, fontSize: 11, color: '#666', lineHeight: 1.5 }}>
+              <div><b>내 것 사용</b>: 이 기기의 변경을 보존하고 원격의 같은 노트 변경을 폐기.</div>
+              <div><b>원격 사용</b>: 원격의 변경을 가져오고 내 변경을 폐기.</div>
+              {onOpenHelp && (
+                <button
+                  onClick={() => onOpenHelp('main-conflict')}
+                  style={{ background: 'none', border: 'none', color: '#0a4b80', cursor: 'pointer', fontSize: 11, padding: 0, marginTop: 2, textDecoration: 'underline' }}
+                >
+                  자세히 보기 →
+                </button>
+              )}
+            </div>
+            <div style={{ marginTop: 8, display: 'flex', gap: 8, justifyContent: 'flex-end' }}>
+              <button
+                onClick={() => { void onChoose(c.path, 'local'); }}
+                disabled={busy === c.path}
+                style={chooseBtnStyle('#0a4b80')}
+              >
+                {busy === c.path ? '처리 중…' : '내 것 사용'}
+              </button>
+              <button
+                onClick={() => { void onChoose(c.path, 'remote'); }}
+                disabled={busy === c.path}
+                style={chooseBtnStyle('#236b1a')}
+              >
+                {busy === c.path ? '처리 중…' : '원격 사용'}
+              </button>
+            </div>
+          </div>
+        ))}
+      </div>
+    </div>
+  );
+}
+
+function preStyle(): React.CSSProperties {
+  return {
+    margin: 0, whiteSpace: 'pre-wrap', fontSize: 11, color: '#444',
+    background: '#fafafa', padding: 6, borderRadius: 3, maxHeight: 120, overflow: 'auto'
+  };
+}
+
+function chooseBtnStyle(color: string): React.CSSProperties {
+  return {
+    background: 'none', border: `1px solid ${color}`, color, cursor: 'pointer',
+    fontSize: 12, padding: '4px 10px', borderRadius: 4
+  };
+}

src/renderer/inbox/components/ExpiryBanner.tsx

@@ -2,6 +2,35 @@ import React, { useEffect, useState } from 'react';
 import type { Note } from '@shared/types';
 import { useInbox } from '../store.js';
 import { Banner } from './Banner.js';
+import { DAY_MS, kstTodayIso } from '@shared/util/kstDate.js';
+
+/**
+ * due_date 대비 오늘 (KST) 의 상대 라벨. 오늘 = "오늘", 지난 = "N일 지남".
+ * findExpiredCandidates 가 미래 due 는 반환하지 않으므로 음수 케이스 미고려.
+ */
+function dueRelativeLabel(due: string, todayKst: string): string {
+  if (due === todayKst) return '오늘';
+  const dueUtc = Date.UTC(
+    Number(due.slice(0, 4)), Number(due.slice(5, 7)) - 1, Number(due.slice(8, 10))
+  );
+  const todayUtc = Date.UTC(
+    Number(todayKst.slice(0, 4)), Number(todayKst.slice(5, 7)) - 1, Number(todayKst.slice(8, 10))
+  );
+  const days = Math.round((todayUtc - dueUtc) / DAY_MS);
+  return `${days}일 지남`;
+}
+
+function headingText(todayCount: number, overdueCount: number): string {
+  if (todayCount > 0 && overdueCount > 0) return `오늘 마감 ${todayCount} · 지난 ${overdueCount}`;
+  if (todayCount > 0) return `오늘 마감 ${todayCount}개`;
+  return `지난 ${overdueCount}개`;
+}
+
+/** RecallBanner 와 동일 패턴 — NoteCard 의 `note-{id}` element 로 smooth scroll. */
+function scrollToNote(id: string): void {
+  const el = document.getElementById(`note-${id}`);
+  if (el) el.scrollIntoView({ behavior: 'smooth', block: 'center' });
+}
 
 export function ExpiryBanner(): React.ReactElement | null {
   const candidates = useInbox((s) => s.expiredCandidates);
@@ -58,6 +87,10 @@ function ExpiryBannerInner({ candidates, onTrash, onSnooze }: InnerProps): React
   const allSelected = candidates.length > 0 && candidates.every((c) => selected.has(c.id));
   const someSelected = selected.size > 0 && !allSelected;
 
+  const todayKst = kstTodayIso();
+  const todayCount = candidates.filter((c) => c.dueDate === todayKst).length;
+  const overdueCount = candidates.length - todayCount;
+
   function toggleAll() {
     if (allSelected) setSelected(new Set());
     else setSelected(new Set(candidates.map((c) => c.id)));
@@ -75,7 +108,7 @@ function ExpiryBannerInner({ candidates, onTrash, onSnooze }: InnerProps): React
   return (
     <Banner severity="warning">
       <div style={{ display: 'flex', alignItems: 'center', gap: 8 }}>
-        <span>⏰ <b>오늘 기준 만료 {candidates.length}개</b></span>
+        <span>⏰ <b>{headingText(todayCount, overdueCount)}</b></span>
         <button
           onClick={() => setExpanded((e) => !e)}
           style={{ background: 'none', border: 'none', cursor: 'pointer', color: '#946100' }}
@@ -107,33 +140,51 @@ function ExpiryBannerInner({ candidates, onTrash, onSnooze }: InnerProps): React
             <span style={{ color: '#666' }}>전체 선택 ({selected.size}/{candidates.length})</span>
           </label>
           <div>
-            {candidates.map((n) => (
-              <label
-                key={n.id}
-                style={{
-                  display: 'flex', alignItems: 'center', gap: 8,
-                  padding: '4px 0', cursor: 'pointer'
-                }}
-              >
-                <input
-                  type="checkbox"
-                  checked={selected.has(n.id)}
-                  onChange={() => toggle(n.id)}
-                />
-                <span style={{ flex: 1, overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }}>
-                  {n.aiTitle ?? n.rawText.slice(0, 60)}
-                </span>
-                <span style={{ color: '#946100', fontSize: 12 }}>due {n.dueDate}</span>
-                {n.tags[0] && (
-                  <span style={{
-                    background: '#fce8b2', color: '#946100', padding: '0 6px',
-                    borderRadius: 10, fontSize: 11
-                  }}>
-                    #{n.tags[0].name}
+            {candidates.map((n) => {
+              const title = n.aiTitle ?? n.rawText.slice(0, 60);
+              return (
+                <div
+                  key={n.id}
+                  style={{
+                    display: 'flex', alignItems: 'center', gap: 8,
+                    padding: '4px 0'
+                  }}
+                >
+                  <input
+                    type="checkbox"
+                    checked={selected.has(n.id)}
+                    onChange={() => toggle(n.id)}
+                    aria-label={`${title} 선택`}
+                  />
+                  <button
+                    type="button"
+                    onClick={() => scrollToNote(n.id)}
+                    title="해당 메모로 이동"
+                    style={{
+                      flex: 1, overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap',
+                      background: 'none', border: 'none', padding: 0,
+                      cursor: 'pointer', color: 'inherit', font: 'inherit', textAlign: 'left'
+                    }}
+                  >
+                    {title}
+                  </button>
+                  <span
+                    style={{ color: '#946100', fontSize: 12 }}
+                    title={`due ${n.dueDate}`}
+                  >
+                    {dueRelativeLabel(n.dueDate ?? todayKst, todayKst)}
                   </span>
-                )}
-              </label>
-            ))}
+                  {n.tags[0] && (
+                    <span style={{
+                      background: '#fce8b2', color: '#946100', padding: '0 6px',
+                      borderRadius: 10, fontSize: 11
+                    }}>
+                      #{n.tags[0].name}
+                    </span>
+                  )}
+                </div>
+              );
+            })}
           </div>
           <button
             onClick={() => onTrash(Array.from(selected))}

src/renderer/inbox/components/MoveStatusModal.tsx

@@ -1,4 +1,4 @@
-import React, { useState } from 'react';
+import React, { useEffect, useState } from 'react';
 import { inboxApi } from '../api.js';
 import type { NoteStatus } from '@shared/types';
 
@@ -6,17 +6,25 @@ interface Props {
   noteId: string;
   rawText: string;
   summary: string;
+  /** 현재 노트 status. 이 값을 제외한 나머지 status 가 이동 버튼으로 노출. */
+  currentStatus: NoteStatus;
   onClose: () => void;
   onMoved: (status: NoteStatus, reason: string | null) => void;
 }
 
 /**
- * v0.2.9 Cut B Task 7 — 메모 이동 Modal.
+ * 메모 이동 Modal.
  *
- * 사유 입력 + 3 status 버튼 (완료/보관/휴지통) + AI 자동 분류.
+ * 사유 입력 + AI 자동 분류 + 수동 status 선택. 버튼은 currentStatus 를 제외한
+ * 나머지 status 만 노출 (v0.3.6 까지는 완료/보관/휴지통 hardcode 라 완료/보관 노트가
+ * inbox 로 못 돌아오던 버그를 v0.3.7 에서 정정).
+ * v0.4 Task 16 — 'archived' 제거. active/completed/trashed 3개 옵션만 노출.
  */
+const ALL_STATUSES: readonly NoteStatus[] = ['active', 'completed', 'trashed'];
+
 export function MoveStatusModal({
   noteId,
+  currentStatus,
   onClose,
   onMoved
 }: Props): React.ReactElement {
@@ -27,6 +35,15 @@ export function MoveStatusModal({
   } | null>(null);
   const [classifying, setClassifying] = useState(false);
 
+  // Escape key 로 modal 닫기. mount 동안만 listener 활성.
+  useEffect(() => {
+    function onKey(e: KeyboardEvent) {
+      if (e.key === 'Escape') onClose();
+    }
+    document.addEventListener('keydown', onKey);
+    return () => document.removeEventListener('keydown', onKey);
+  }, [onClose]);
+
   async function move(status: NoteStatus): Promise<void> {
     const trimmedReason = reason.trim() === '' ? null : reason.trim();
     await inboxApi.setStatus(noteId, status, trimmedReason);
@@ -48,6 +65,7 @@ export function MoveStatusModal({
     <div
       role="dialog"
       aria-label="이동"
+      onClick={onClose}
       style={{
         position: 'fixed',
         top: 0,
@@ -62,6 +80,7 @@ export function MoveStatusModal({
       }}
     >
       <div
+        onClick={(e) => e.stopPropagation()}
         style={{
           background: '#fff',
           padding: 16,
@@ -90,9 +109,11 @@ export function MoveStatusModal({
           <button onClick={() => void classify()} disabled={classifying}>
             {classifying ? '분류 중...' : 'AI 자동 분류'}
           </button>
-          <button onClick={() => void move('completed')}>완료</button>
-          <button onClick={() => void move('archived')}>보관</button>
-          <button onClick={() => void move('trashed')}>휴지통</button>
+          {ALL_STATUSES.filter((s) => s !== currentStatus).map((s) => (
+            <button key={s} onClick={() => void move(s)}>
+              {statusLabel(s)}
+            </button>
+          ))}
           <button onClick={onClose} style={{ marginLeft: 'auto' }}>
             취소
           </button>
@@ -126,11 +147,10 @@ export function MoveStatusModal({
 export function statusLabel(s: NoteStatus): string {
   switch (s) {
     case 'active':
-      return '활성';
+      // 헤더 탭 표기 ('Inbox') 와 일치. UI 전반에서 active = Inbox 동의어.
+      return 'Inbox';
     case 'completed':
       return '완료';
-    case 'archived':
-      return '보관';
     case 'trashed':
       return '휴지통';
   }

src/renderer/inbox/components/NoteCard.tsx

@@ -1,11 +1,12 @@
 import React, { useState } from 'react';
-import type { Note, NoteStatus } from '@shared/types';
+import type { Note, Notebook } from '@shared/types';
+import { KST_OFFSET_MS } from '@shared/util/kstDate.js';
 import { inboxApi } from '../api.js';
 import { useInbox } from '../store.js';
 import { EditableField } from './EditableField.js';
 import { IntentBanner } from './IntentBanner.js';
 import { pushTagUndo } from './TagUndoToast.js';
-import { MoveStatusModal, statusLabelWithParticle } from './MoveStatusModal.js';
+import { MoveStatusModal } from './MoveStatusModal.js';
 import { RevisionHistoryModal } from './RevisionHistoryModal.js';
 
 interface Props {
@@ -27,7 +28,6 @@ function isPastDue(iso: string, today: string): boolean {
 }
 
 function todayKstIso(): string {
-  const KST_OFFSET_MS = 9 * 60 * 60 * 1000;
   const k = new Date(Date.now() + KST_OFFSET_MS);
   return k.toISOString().slice(0, 10);
 }
@@ -109,6 +109,64 @@ function DueDateBadge({
   );
 }
 
+function NotebookChip({ current, notebooks, onMove }: {
+  current: Notebook;
+  notebooks: Notebook[];
+  onMove: (id: string) => Promise<void>;
+}): React.ReactElement {
+  const [open, setOpen] = useState(false);
+  const others = notebooks.filter((nb) => nb.id !== current.id);
+  const hasOthers = others.length > 0;
+  return (
+    <span style={{ position: 'relative', display: 'inline-block' }}>
+      <button
+        onClick={() => hasOthers && setOpen(!open)}
+        title={hasOthers ? '다른 노트북으로 이동' : '현재 노트북'}
+        disabled={!hasOthers}
+        style={{
+          display: 'inline-flex', alignItems: 'center', gap: 4,
+          background: '#eaf3ff', color: '#0a4b80',
+          border: '1px solid #cfe0f5', borderRadius: 10,
+          padding: '2px 8px', fontSize: 11, cursor: hasOthers ? 'pointer' : 'default'
+        }}
+      >
+        <span style={{ width: 6, height: 6, borderRadius: '50%', background: current.color ?? '#bbb', display: 'inline-block' }} />
+        📓 {current.name}
+        {hasOthers && <span style={{ fontSize: 9, opacity: 0.6 }}>▾</span>}
+      </button>
+      {open && hasOthers && (
+        <div
+          style={{
+            position: 'absolute', bottom: '100%', left: 0,
+            background: '#fff', border: '1px solid #ccc', borderRadius: 4,
+            zIndex: 50, minWidth: 140, boxShadow: '0 2px 6px rgba(0,0,0,0.15)',
+            marginBottom: 2
+          }}
+        >
+          <div style={{ fontSize: 10, color: '#888', padding: '4px 10px', borderBottom: '1px solid #eee' }}>
+            이동할 노트북
+          </div>
+          {others.map((nb) => (
+            <button
+              key={nb.id}
+              onClick={async () => { await onMove(nb.id); setOpen(false); }}
+              style={{
+                display: 'flex', alignItems: 'center', gap: 6,
+                width: '100%', textAlign: 'left',
+                padding: '4px 10px', border: 'none', background: 'transparent',
+                cursor: 'pointer', fontSize: 11
+              }}
+            >
+              <span style={{ width: 6, height: 6, borderRadius: '50%', background: nb.color ?? '#bbb', display: 'inline-block' }} />
+              {nb.name}
+            </button>
+          ))}
+        </div>
+      )}
+    </span>
+  );
+}
+
 export function NoteCard({ note, onDeleted, onUpdated, mode = 'inbox', onRestore, onPermanentDelete }: Props): React.ReactElement {
   const isTrash = mode === 'trash';
   // v0.2.9 Cut B Task 13 — ai_status='disabled' 노트는 raw_text 가 1차 정보. 원문 펼침 default 켬.
@@ -116,16 +174,15 @@ export function NoteCard({ note, onDeleted, onUpdated, mode = 'inbox', onRestore
   const [local, setLocal] = useState(note);
   const isAiDisabled = local.aiStatus === 'disabled';
   const fallbackTitle = local.rawText.split('\n')[0]?.slice(0, 60) || '(빈 메모)';
-  // v0.2.9 Cut B Task 6 — 이동 메뉴 dropdown + MoveStatusModal target.
-  const [moveTarget, setMoveTarget] = useState<NoteStatus | null>(null);
-  const [menuOpen, setMenuOpen] = useState(false);
+  // 이동 modal 열림 여부. 클릭 시 MoveStatusModal 에서 사유 + AI 분류 + 수동 분류 선택.
+  const [moveOpen, setMoveOpen] = useState(false);
   const [editingRaw, setEditingRaw] = useState(false);
   const [draftRaw, setDraftRaw] = useState('');
   const [showRevisions, setShowRevisions] = useState(false);
 
-  const possibleTargets: NoteStatus[] = (
-    ['active', 'completed', 'archived', 'trashed'] as NoteStatus[]
-  ).filter((s) => s !== local.status);
+  const notebooks = useInbox((s) => s.notebooks);
+  const moveNoteToNotebook = useInbox((s) => s.moveNoteToNotebook);
+  const currentNb = notebooks.find((nb) => nb.id === local.notebookId);
 
   React.useEffect(() => { setLocal(note); }, [note]);
 
@@ -159,7 +216,15 @@ export function NoteCard({ note, onDeleted, onUpdated, mode = 'inbox', onRestore
     if (next.trim().length === 0) return;
     const r = await inboxApi.updateRawText(note.id, next);
     if (!r.ok) return;
-    const updated = { ...local, rawText: next, updatedAt: new Date().toISOString() };
+    // disabled 노트는 AI 재처리 안 됨 (서버에서 skip) — aiStatus 유지.
+    // 그 외는 optimistic 으로 pending 표시 → AiWorker 완료 시 push 로 자동 sync.
+    const willReprocess = local.aiStatus !== 'disabled';
+    const updated = {
+      ...local,
+      rawText: next,
+      updatedAt: new Date().toISOString(),
+      ...(willReprocess ? { aiStatus: 'pending' as const, aiError: null } : {})
+    };
     setLocal(updated);
     onUpdated(updated);
     setEditingRaw(false);
@@ -220,13 +285,61 @@ export function NoteCard({ note, onDeleted, onUpdated, mode = 'inbox', onRestore
       )}
 
       {local.aiStatus === 'pending' && (
-        <div style={{ fontSize: 16, fontWeight: 600, color: '#666', marginTop: 4 }}>
-          Inkling이 정리하는 중…
+        <div style={{ marginTop: 4, display: 'flex', alignItems: 'center', gap: 8 }}>
+          <div style={{ fontSize: 16, fontWeight: 600, color: '#666' }}>
+            Inkling이 정리하는 중…
+          </div>
+          {/* v0.3.9 — pending cancel UI. Ollama 끊김 / 무한 pending 시 사용자 unblock path. */}
+          <button
+            onClick={async () => {
+              await inboxApi.cancelPending(local.id);
+              // push 기반 — onNoteUpdated 가 store 자동 갱신.
+            }}
+            style={{
+              background: 'none', border: '1px solid #ccc', color: '#666',
+              cursor: 'pointer', fontSize: 11, padding: '2px 8px', borderRadius: 4
+            }}
+            title="AI 자동 처리를 건너뛰고 원문만 보관"
+          >
+            건너뛰기
+          </button>
         </div>
       )}
       {local.aiStatus === 'failed' && (
-        <div title={local.aiError ?? ''} style={{ fontSize: 16, fontWeight: 600, color: '#a55', marginTop: 4 }}>
-          정리 보류 — 원문은 안전합니다
+        <div style={{ marginTop: 4 }}>
+          <div style={{ display: 'flex', alignItems: 'center', gap: 8 }}>
+            <div style={{ fontSize: 16, fontWeight: 600, color: '#a55' }}>
+              정리 보류 — 원문은 안전합니다
+            </div>
+            {/* v0.3.9 — per-note 재시도 UI. FailedBanner 의 일괄 재시도와 별개. */}
+            <button
+              onClick={async () => {
+                await inboxApi.retryOneFailed(local.id);
+              }}
+              style={{
+                background: 'none', border: '1px solid #a55', color: '#a55',
+                cursor: 'pointer', fontSize: 11, padding: '2px 8px', borderRadius: 4
+              }}
+              title="이 노트만 AI 처리 재시도"
+            >
+              재시도
+            </button>
+          </div>
+          {/* v0.3.14 — fail 원인 inline 표시. ai_error 의 raw message 가 그대로 사용자에게
+              보여서 디버깅 + 모델/네트워크 이슈 진단 가능. 너무 길면 <details> 로 접힘. */}
+          {local.aiError !== null && local.aiError.length > 0 && (
+            <details style={{ marginTop: 4 }}>
+              <summary style={{ fontSize: 12, color: '#a55', cursor: 'pointer' }}>
+                원인 보기
+              </summary>
+              <pre style={{
+                fontSize: 11, color: '#666', background: '#fff0f0', padding: 6,
+                borderRadius: 4, marginTop: 4, whiteSpace: 'pre-wrap', wordBreak: 'break-word'
+              }}>
+                {local.aiError}
+              </pre>
+            </details>
+          )}
         </div>
       )}
       {/* v0.2.9 Cut B Task 13 — ai_status='disabled': raw_text 첫 줄 fallback title.
@@ -424,64 +537,34 @@ export function NoteCard({ note, onDeleted, onUpdated, mode = 'inbox', onRestore
             alignItems: 'center'
           }}
         >
-          {/* v0.2.9 Cut B Task 6 — 모든 view 공통 "이동 ▾" dropdown.
-              현재 status 와 다른 3개 목적지만 표시. */}
-          <div style={{ position: 'relative' }}>
-            <button
-              onClick={() => setMenuOpen((o) => !o)}
-              aria-label="이동"
-              style={{
-                background: 'none',
-                border: '1px solid #ccc',
-                color: '#444',
-                cursor: 'pointer',
-                fontSize: 12,
-                padding: '4px 10px',
-                borderRadius: 4
+          {/* notebook chip — tag(키워드)와 notebook(컨텍스트) 의미 분리. done + inbox 에서만 표시. */}
+          {!isTrash && local.aiStatus === 'done' && currentNb && (
+            <NotebookChip
+              current={currentNb}
+              notebooks={notebooks}
+              onMove={async (newId) => {
+                await moveNoteToNotebook(local.id, newId);
+                setLocal({ ...local, notebookId: newId });
               }}
-            >
-              이동 ▾
-            </button>
-            {menuOpen && (
-              <div
-                style={{
-                  position: 'absolute',
-                  right: 0,
-                  top: '100%',
-                  marginTop: 2,
-                  background: '#fff',
-                  border: '1px solid #ccc',
-                  borderRadius: 4,
-                  padding: 4,
-                  zIndex: 10,
-                  minWidth: 140,
-                  boxShadow: '0 2px 6px rgba(0,0,0,0.08)'
-                }}
-              >
-                {possibleTargets.map((t) => (
-                  <button
-                    key={t}
-                    onClick={() => {
-                      setMoveTarget(t);
-                      setMenuOpen(false);
-                    }}
-                    style={{
-                      display: 'block',
-                      width: '100%',
-                      textAlign: 'left',
-                      background: 'none',
-                      border: 'none',
-                      padding: '6px 8px',
-                      fontSize: 12,
-                      cursor: 'pointer'
-                    }}
-                  >
-                    {statusLabelWithParticle(t)} 이동
-                  </button>
-                ))}
-              </div>
-            )}
-          </div>
+            />
+          )}
+          {/* 이동 버튼 — 클릭 시 MoveStatusModal 진입.
+              사유 입력 + AI 자동 분류 + 수동 status 선택 한 곳에서 처리. */}
+          <button
+            onClick={() => setMoveOpen(true)}
+            aria-label="이동"
+            style={{
+              background: 'none',
+              border: '1px solid #ccc',
+              color: '#444',
+              cursor: 'pointer',
+              fontSize: 12,
+              padding: '4px 10px',
+              borderRadius: 4
+            }}
+          >
+            이동
+          </button>
 
           {/* trash mode 만 영구 삭제 + 복구 보존 (휴지통 단독 액션). */}
           {isTrash && (
@@ -509,19 +592,23 @@ export function NoteCard({ note, onDeleted, onUpdated, mode = 'inbox', onRestore
         </div>
       </div>
 
-      {moveTarget !== null && (
+      {moveOpen && (
         <MoveStatusModal
           noteId={local.id}
           rawText={local.rawText}
           summary={local.aiSummary ?? ''}
-          onClose={() => setMoveTarget(null)}
+          currentStatus={local.status}
+          onClose={() => setMoveOpen(false)}
           onMoved={(newStatus, reason) => {
             const updated = { ...local, status: newStatus, moveReason: reason };
             setLocal(updated);
             onUpdated(updated);
-            // inbox/trash mode 의 list 가 status 별로 필터되므로 onDeleted (제거) 도 호출.
+            // inbox/완료/보관/휴지통 view 의 list 가 status 별로 필터되므로 status 변경 시 onDeleted 호출.
             if (newStatus !== local.status) onDeleted?.();
-            setMoveTarget(null);
+            // setStatus IPC 는 pushNoteUpdated emit 안 함 → 헤더 탭 counts 가 stale.
+            // refreshMeta 로 server-authoritative counts 재로드.
+            void useInbox.getState().refreshMeta();
+            setMoveOpen(false);
           }}
         />
       )}

src/renderer/inbox/components/NotebookCreateModal.tsx

@@ -0,0 +1,64 @@
+import React, { useState } from 'react';
+import { useInbox } from '../store.js';
+
+const COLOR_PALETTE = ['#0a4b80', '#236b1a', '#946100', '#a55', '#5a3a8c', '#1a5b6e'];
+
+export function NotebookCreateModal({ onClose }: { onClose: () => void }): React.ReactElement {
+  const createNotebook = useInbox((s) => s.createNotebook);
+  const [name, setName] = useState('');
+  const [color, setColor] = useState<string>(COLOR_PALETTE[0]!);
+  const [err, setErr] = useState<string | null>(null);
+
+  async function onSubmit() {
+    const r = await createNotebook(name.trim(), color);
+    if (r.ok) onClose();
+    else setErr(r.reason === 'duplicate_name' ? '같은 이름의 노트북이 이미 있어요.' : (r.reason ?? '저장 실패'));
+  }
+
+  return (
+    <div
+      onClick={onClose}
+      style={{ position: 'fixed', inset: 0, background: 'rgba(0,0,0,0.4)', display: 'flex', alignItems: 'center', justifyContent: 'center', zIndex: 120 }}
+    >
+      <div
+        onClick={(e) => e.stopPropagation()}
+        style={{ background: '#fff', padding: 20, borderRadius: 8, width: 360 }}
+      >
+        <h3 style={{ margin: '0 0 12px 0', fontSize: 15 }}>새 노트북</h3>
+        <input
+          aria-label="노트북 이름"
+          value={name}
+          onChange={(e) => setName(e.target.value)}
+          placeholder="예: 회사, 학습"
+          autoFocus
+          style={{ width: '100%', padding: '6px 8px', fontSize: 13, border: '1px solid #ccc', borderRadius: 4, boxSizing: 'border-box' }}
+        />
+        <div style={{ display: 'flex', gap: 6, marginTop: 10 }}>
+          {COLOR_PALETTE.map((c) => (
+            <button
+              key={c}
+              onClick={() => setColor(c)}
+              aria-label={`색 ${c}`}
+              style={{
+                width: 24, height: 24, borderRadius: '50%',
+                background: c, border: c === color ? '2px solid #333' : '1px solid #ccc',
+                cursor: 'pointer', padding: 0
+              }}
+            />
+          ))}
+        </div>
+        {err && <div style={{ color: '#c33', fontSize: 12, marginTop: 8 }}>{err}</div>}
+        <div style={{ display: 'flex', gap: 8, justifyContent: 'flex-end', marginTop: 14 }}>
+          <button onClick={onClose} style={{ padding: '5px 12px', fontSize: 12 }}>취소</button>
+          <button
+            onClick={() => { void onSubmit(); }}
+            disabled={name.trim().length === 0}
+            style={{ padding: '5px 12px', fontSize: 12, background: '#0a4b80', color: '#fff', border: 'none', borderRadius: 4, cursor: name.trim().length === 0 ? 'not-allowed' : 'pointer', opacity: name.trim().length === 0 ? 0.5 : 1 }}
+          >
+            만들기
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}

src/renderer/inbox/components/NotebookList.tsx

@@ -0,0 +1,79 @@
+import React, { useState } from 'react';
+import type { Notebook } from '@shared/types';
+
+interface Props {
+  notebooks: Notebook[];
+  selectedId: string | null;
+  onSelect: (id: string) => void;
+  onCreate: () => void;
+  onReorder?: (id: string, direction: 'up' | 'down') => Promise<void>;
+}
+
+export function NotebookList({ notebooks, selectedId, onSelect, onCreate, onReorder }: Props): React.ReactElement {
+  const [hoverId, setHoverId] = useState<string | null>(null);
+
+  return (
+    <div style={{ display: 'flex', flexDirection: 'column' }}>
+      {notebooks.map((nb, idx) => {
+        const active = nb.id === selectedId;
+        const hover = nb.id === hoverId;
+        const isFirst = idx === 0;
+        const isLast = idx === notebooks.length - 1;
+        return (
+          <div
+            key={nb.id}
+            onMouseEnter={() => setHoverId(nb.id)}
+            onMouseLeave={() => setHoverId(null)}
+            style={{ position: 'relative', display: 'flex' }}
+          >
+            <button
+              onClick={() => onSelect(nb.id)}
+              style={{
+                display: 'flex', alignItems: 'center', gap: 8,
+                padding: '6px 12px', background: active ? '#eaf3ff' : 'transparent',
+                border: 'none', cursor: 'pointer', textAlign: 'left',
+                color: active ? '#0a4b80' : '#333', fontSize: 13, flex: 1
+              }}
+            >
+              <span style={{
+                width: 8, height: 8, borderRadius: '50%',
+                background: nb.color ?? '#bbb', flexShrink: 0
+              }} />
+              <span style={{ flex: 1, overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }}>
+                {nb.name}
+              </span>
+              <span style={{ fontSize: 11, color: '#888' }}>{nb.noteCount}</span>
+            </button>
+            {hover && onReorder && notebooks.length > 1 && (
+              <div style={{ position: 'absolute', right: 4, top: 2, display: 'flex', gap: 2 }}>
+                <button
+                  onClick={(e) => { e.stopPropagation(); if (!isFirst) void onReorder(nb.id, 'up'); }}
+                  disabled={isFirst}
+                  aria-label={`${nb.name} 위로`}
+                  title="위로"
+                  style={{ background: 'rgba(255,255,255,0.9)', border: '1px solid #ccc', borderRadius: 3, fontSize: 10, padding: '0 4px', cursor: isFirst ? 'not-allowed' : 'pointer', opacity: isFirst ? 0.3 : 1 }}
+                >▲</button>
+                <button
+                  onClick={(e) => { e.stopPropagation(); if (!isLast) void onReorder(nb.id, 'down'); }}
+                  disabled={isLast}
+                  aria-label={`${nb.name} 아래로`}
+                  title="아래로"
+                  style={{ background: 'rgba(255,255,255,0.9)', border: '1px solid #ccc', borderRadius: 3, fontSize: 10, padding: '0 4px', cursor: isLast ? 'not-allowed' : 'pointer', opacity: isLast ? 0.3 : 1 }}
+                >▼</button>
+              </div>
+            )}
+          </div>
+        );
+      })}
+      <button
+        onClick={onCreate}
+        style={{
+          padding: '6px 12px', background: 'transparent', border: 'none',
+          cursor: 'pointer', textAlign: 'left', color: '#888', fontSize: 12
+        }}
+      >
+        + 새 노트북
+      </button>
+    </div>
+  );
+}

src/renderer/inbox/components/OnboardingWizard.tsx

@@ -1,4 +1,4 @@
-import React from 'react';
+import React, { useEffect, useState } from 'react';
 import { inboxApi } from '../api.js';
 
 /**
@@ -10,12 +10,42 @@ import { inboxApi } from '../api.js';
  * 가 SettingsPage 에서 추후 선택 가능.
  */
 export function OnboardingWizard({ onClose }: { onClose: () => void }): React.ReactElement {
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
   async function choose(aiEnabled: boolean | null): Promise<void> {
-    if (aiEnabled !== null) await inboxApi.setAiEnabled(aiEnabled);
-    await inboxApi.setOnboardingCompleted(true);
+    setBusy(true);
+    setError(null);
+    try {
+      if (aiEnabled !== null) await inboxApi.setAiEnabled(aiEnabled);
+      await inboxApi.setOnboardingCompleted(true);
+      onClose();
+    } catch (e) {
+      // IPC 실패 (예: settings 저장 throw) 시 modal stuck 방지. 사용자에게 메시지 표시 +
+      // "지금 건너뛰기" 로 fallback 길 제공. choose() 가 throw 하지 않고 무한 wizard 잠금
+      // 회피.
+      setError((e as Error).message);
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  function skip(): void {
+    // IPC 자체가 실패하는 상태 → ai_enabled 변경/onboarding flag 저장 모두 포기하고 wizard 만 닫기.
+    // 다음 launch 에 다시 wizard 가 뜸 (onboarding_completed=false 상태). 그래도 사용자가
+    // 진입 자체는 가능.
     onClose();
   }
 
+  // Escape key 로 wizard 종료 (skip 동일 — onboarding flag 미저장).
+  useEffect(() => {
+    function onKey(e: KeyboardEvent) {
+      if (e.key === 'Escape') skip();
+    }
+    document.addEventListener('keydown', onKey);
+    return () => document.removeEventListener('keydown', onKey);
+  }, []);
+
   return (
     <div role="dialog" aria-label="시작 안내" style={{
       position: 'fixed', top: 0, left: 0, right: 0, bottom: 0,
@@ -32,10 +62,16 @@ export function OnboardingWizard({ onClose }: { onClose: () => void }): React.Re
           <a href="https://ollama.com/download" target="_blank" rel="noopener noreferrer">ollama.com/download</a>
         </p>
         <div style={{ display: 'flex', flexDirection: 'column', gap: 8 }}>
-          <button onClick={() => choose(true)}>AI 자동 처리 사용 (Ollama 필요)</button>
-          <button onClick={() => choose(false)}>원문만 저장 (AI 처리 안 함)</button>
-          <button onClick={() => choose(null)} style={{ marginTop: 4 }}>나중에 설정</button>
+          <button onClick={() => choose(true)} disabled={busy}>AI 자동 처리 사용 (Ollama 필요)</button>
+          <button onClick={() => choose(false)} disabled={busy}>원문만 저장 (AI 처리 안 함)</button>
+          <button onClick={() => choose(null)} disabled={busy} style={{ marginTop: 4 }}>나중에 설정</button>
         </div>
+        {error !== null && (
+          <div style={{ marginTop: 12, padding: 8, background: '#fdecea', color: '#a3261c', fontSize: 12, borderRadius: 4 }}>
+            <div>설정 저장 실패: {error}</div>
+            <button onClick={skip} style={{ marginTop: 8 }}>지금 건너뛰기</button>
+          </div>
+        )}
       </div>
     </div>
   );

src/renderer/inbox/components/PromotionBanner.tsx

@@ -0,0 +1,78 @@
+import React, { useState } from 'react';
+import { useInbox } from '../store.js';
+import { Banner } from './Banner.js';
+
+const COLOR_PALETTE = ['#0a4b80', '#236b1a', '#946100', '#a55', '#5a3a8c'];
+
+export function PromotionBanner(): React.ReactElement | null {
+  const candidates = useInbox((s) => s.promotionCandidates);
+  const accept = useInbox((s) => s.acceptPromotion);
+  const snooze = useInbox((s) => s.snoozePromotion);
+  const dismiss = useInbox((s) => s.dismissPromotion);
+  const [editing, setEditing] = useState<{ tag: string; name: string; color: string } | null>(null);
+
+  if (candidates.length === 0) return null;
+  const c = candidates[0]!;
+
+  return (
+    <Banner severity="info">
+      {editing === null ? (
+        <div style={{ display: 'flex', alignItems: 'center', gap: 8, flexWrap: 'wrap' }}>
+          <span>💡 <code>{c.tag}</code> 관련 노트 {c.noteIds.length}개가 모였어요. 새 노트북 <b>{c.suggestedName}</b> 로 분리할까요?</span>
+          <div style={{ display: 'flex', gap: 6, marginLeft: 'auto' }}>
+            <button
+              onClick={() => setEditing({ tag: c.tag, name: c.suggestedName, color: COLOR_PALETTE[0]! })}
+              style={{ background: '#0a4b80', color: '#fff', border: 'none', borderRadius: 4, padding: '4px 12px', fontSize: 12, cursor: 'pointer' }}
+            >
+              수락
+            </button>
+            <button
+              onClick={() => { void snooze(); }}
+              style={{ background: 'transparent', color: '#234', border: '1px solid #ccc', borderRadius: 4, padding: '4px 12px', fontSize: 12, cursor: 'pointer' }}
+            >
+              나중에
+            </button>
+            <button
+              onClick={() => { void dismiss(c.tag); }}
+              style={{ background: 'transparent', color: '#888', border: 'none', cursor: 'pointer', fontSize: 12 }}
+            >
+              숨기기
+            </button>
+          </div>
+        </div>
+      ) : (
+        <div style={{ display: 'flex', alignItems: 'center', gap: 8, flexWrap: 'wrap' }}>
+          <input
+            aria-label="노트북 이름"
+            value={editing.name}
+            onChange={(e) => setEditing({ ...editing, name: e.target.value })}
+            style={{ flex: 1, fontSize: 13, padding: '4px 8px', border: '1px solid #ccc', borderRadius: 4, minWidth: 120 }}
+            autoFocus
+          />
+          <div style={{ display: 'flex', gap: 4 }}>
+            {COLOR_PALETTE.map((col) => (
+              <button
+                key={col}
+                onClick={() => setEditing({ ...editing, color: col })}
+                aria-label={`색 ${col}`}
+                style={{
+                  width: 20, height: 20, borderRadius: '50%', background: col,
+                  border: col === editing.color ? '2px solid #333' : '1px solid #ccc',
+                  cursor: 'pointer', padding: 0
+                }}
+              />
+            ))}
+          </div>
+          <button
+            onClick={() => { void accept(editing.tag, editing.name.trim(), editing.color); setEditing(null); }}
+            disabled={editing.name.trim().length === 0}
+            style={{ background: '#0a4b80', color: '#fff', border: 'none', borderRadius: 4, padding: '4px 12px', fontSize: 12, cursor: 'pointer' }}
+          >
+            만들기
+          </button>
+          <button onClick={() => setEditing(null)} style={{ fontSize: 12, padding: '4px 10px' }}>취소</button>
+        </div>
+      )}
+    </Banner>
+  );
+}

src/renderer/inbox/components/ReviewView.tsx

@@ -0,0 +1,80 @@
+import React from 'react';
+import { useInbox } from '../store.js';
+import { NoteCard } from './NoteCard.js';
+
+interface Props {
+  period: 'daily' | 'weekly' | 'monthly';
+}
+
+const periodLabel: Record<Props['period'], string> = {
+  daily: '일간',
+  weekly: '주간',
+  monthly: '월간'
+};
+
+export function ReviewView({ period }: Props): React.ReactElement {
+  const reviewData = useInbox((s) => s.reviewData);
+  const setView = useInbox((s) => s.setView);
+  const backButton = (
+    <button
+      onClick={() => setView('inbox')}
+      style={{
+        background: 'transparent',
+        border: 'none',
+        fontSize: 14,
+        cursor: 'pointer',
+        color: '#0a4b80',
+        padding: 0
+      }}
+    >
+      ← 돌아가기
+    </button>
+  );
+  if (!reviewData) {
+    return (
+      <div style={{ padding: 16 }}>
+        <div style={{ marginBottom: 12 }}>{backButton}</div>
+        <div style={{ fontSize: 13, color: '#666' }}>불러오는 중…</div>
+      </div>
+    );
+  }
+  const max = reviewData.tagCounts[0]?.count ?? 1;
+  return (
+    <div style={{ padding: 16 }}>
+      <div style={{ display: 'flex', alignItems: 'center', gap: 8, marginBottom: 8 }}>
+        {backButton}
+        <h2 style={{ fontSize: 18, margin: 0 }}>{periodLabel[period]} 회고</h2>
+      </div>
+      <div style={{ marginTop: 8, fontSize: 13, color: '#444' }}>
+        총 {reviewData.totalCount}건
+      </div>
+      <section style={{ marginTop: 16 }}>
+        <h3 style={{ fontSize: 14, marginBottom: 4 }}>태그 분포</h3>
+        {reviewData.tagCounts.length === 0 && (
+          <div style={{ fontSize: 12, color: '#888' }}>태그 없음</div>
+        )}
+        {reviewData.tagCounts.slice(0, 10).map((t) => (
+          <div key={t.tag} style={{ display: 'flex', alignItems: 'center', gap: 6, marginTop: 2 }}>
+            <span style={{ fontSize: 12, width: 80 }}>{t.tag}</span>
+            <div style={{ flex: 1, background: '#eee', height: 8, borderRadius: 2 }}>
+              <div style={{ width: `${(t.count / max) * 100}%`, background: '#4ec5b8', height: 8, borderRadius: 2 }} />
+            </div>
+            <span style={{ fontSize: 12, color: '#666', width: 30, textAlign: 'right' }}>{t.count}</span>
+          </div>
+        ))}
+      </section>
+      <section style={{ marginTop: 16 }}>
+        <h3 style={{ fontSize: 14, marginBottom: 4 }}>마감 진행</h3>
+        <div style={{ fontSize: 13, color: '#444' }}>
+          완료 {reviewData.dueProgress.passed} / {reviewData.dueProgress.total} · 대기 {reviewData.dueProgress.pending}
+        </div>
+      </section>
+      <section style={{ marginTop: 16 }}>
+        <h3 style={{ fontSize: 14, marginBottom: 4 }}>최근 노트 ({reviewData.recentNotes.length})</h3>
+        {reviewData.recentNotes.map((n) => (
+          <NoteCard key={n.id} note={n} mode="inbox" onUpdated={() => {}} />
+        ))}
+      </section>
+    </div>
+  );
+}

src/renderer/inbox/components/RevisionHistoryModal.tsx

@@ -37,6 +37,15 @@ export function RevisionHistoryModal({ noteId, onClose, onRestored }: Props): Re
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState<string | null>(null);
 
+  // Escape key 로 닫기.
+  useEffect(() => {
+    function onKey(e: KeyboardEvent) {
+      if (e.key === 'Escape') onClose();
+    }
+    document.addEventListener('keydown', onKey);
+    return () => document.removeEventListener('keydown', onKey);
+  }, [onClose]);
+
   useEffect(() => {
     let cancelled = false;
     void (async () => {

src/renderer/inbox/components/SearchBox.tsx

@@ -0,0 +1,52 @@
+import React, { useEffect, useState } from 'react';
+import { useInbox } from '../store.js';
+
+export function SearchBox(): React.ReactElement {
+  const [draft, setDraft] = useState('');
+  const [scope, setScope] = useState<'current' | 'all'>('current');
+  const selectedNotebookId = useInbox((s) => s.selectedNotebookId);
+
+  useEffect(() => {
+    const handle = setTimeout(() => {
+      const trimmed = draft.trim();
+      if (trimmed.length === 0) {
+        useInbox.getState().clearSearch();
+      } else {
+        // v0.4 Task 18 — scope='current' 이면 현재 notebook ID 전달, 'all' 이면 미전달(전체 검색).
+        const notebookId = scope === 'current' ? (selectedNotebookId ?? undefined) : undefined;
+        void useInbox.getState().searchNotes(trimmed, { notebookId });
+      }
+    }, 200);
+    return () => clearTimeout(handle);
+  }, [draft, scope, selectedNotebookId]);
+
+  return (
+    <span style={{ display: 'inline-flex', alignItems: 'center' }}>
+      <input
+        type="search"
+        role="searchbox"
+        placeholder="검색…"
+        value={draft}
+        onChange={(e) => setDraft(e.target.value)}
+        aria-label="노트 검색"
+        style={{
+          marginLeft: 12,
+          padding: '4px 8px',
+          fontSize: 12,
+          border: '1px solid #bbb',
+          borderRadius: 4,
+          width: 200
+        }}
+      />
+      <select
+        value={scope}
+        onChange={(e) => setScope(e.target.value as 'current' | 'all')}
+        aria-label="검색 범위"
+        style={{ fontSize: 11, padding: '2px 4px', marginLeft: 4 }}
+      >
+        <option value="current">이 노트북</option>
+        <option value="all">모든 노트북</option>
+      </select>
+    </span>
+  );
+}

src/renderer/inbox/components/SettingsPage.tsx

@@ -4,6 +4,7 @@ import { AiProviderSection } from './settings/AiProviderSection.js';
 import { AutostartSection } from './settings/AutostartSection.js';
 import { BackupSection } from './settings/BackupSection.js';
 import { InfoSection } from './settings/InfoSection.js';
+import { SyncSection } from './settings/SyncSection.js';
 
 export function SettingsPage(): React.ReactElement {
   const setShowSettings = useInbox((s) => s.setShowSettings);
@@ -40,6 +41,10 @@ export function SettingsPage(): React.ReactElement {
         <h2 style={{ fontSize: 14, marginBottom: 8 }}>정보</h2>
         <InfoSection />
       </section>
+      <section style={{ marginBottom: 24 }}>
+        <h2 style={{ fontSize: 14, marginBottom: 8 }}>동기화</h2>
+        <SyncSection />
+      </section>
     </div>
   );
 }

src/renderer/inbox/components/Sidebar.tsx

@@ -0,0 +1,33 @@
+import React, { useState } from 'react';
+import { useInbox } from '../store.js';
+import { NotebookList } from './NotebookList.js';
+import { NotebookCreateModal } from './NotebookCreateModal.js';
+
+export function Sidebar(): React.ReactElement | null {
+  const visible = useInbox((s) => s.sidebarVisible);
+  const width = useInbox((s) => s.sidebarWidth);
+  const notebooks = useInbox((s) => s.notebooks);
+  const selectedId = useInbox((s) => s.selectedNotebookId);
+  const selectNotebook = useInbox((s) => s.selectNotebook);
+  const reorderNotebook = useInbox((s) => s.reorderNotebook);
+  const [createOpen, setCreateOpen] = useState(false);
+
+  if (!visible) return null;
+
+  return (
+    <aside style={{
+      width, borderRight: '1px solid #e0e0e0',
+      background: '#fafafa', overflowY: 'auto',
+      flexShrink: 0
+    }}>
+      <NotebookList
+        notebooks={notebooks}
+        selectedId={selectedId}
+        onSelect={selectNotebook}
+        onCreate={() => setCreateOpen(true)}
+        onReorder={reorderNotebook}
+      />
+      {createOpen && <NotebookCreateModal onClose={() => setCreateOpen(false)} />}
+    </aside>
+  );
+}

src/renderer/inbox/components/SyncHelpModal.tsx

@@ -0,0 +1,132 @@
+import React, { useEffect, useRef } from 'react';
+
+export type SyncHelpAnchor = 'main-conflict' | 'auto' | 'silent' | 'setup';
+
+interface Props {
+  onClose: () => void;
+  initialAnchor?: SyncHelpAnchor;
+}
+
+const overlayStyle: React.CSSProperties = {
+  position: 'fixed', top: 0, left: 0, width: '100vw', height: '100vh',
+  background: 'rgba(0,0,0,0.4)', display: 'flex', alignItems: 'center',
+  justifyContent: 'center', zIndex: 110
+};
+
+const modalStyle: React.CSSProperties = {
+  background: '#fff', borderRadius: 8, padding: 20, width: 640,
+  maxHeight: '80vh', overflow: 'auto', boxShadow: '0 4px 16px rgba(0,0,0,0.2)'
+};
+
+const sectionStyle: React.CSSProperties = {
+  marginTop: 18, paddingTop: 12, borderTop: '1px solid #eee'
+};
+
+const h4Style: React.CSSProperties = { fontSize: 14, margin: '0 0 8px 0' };
+const pStyle: React.CSSProperties = { fontSize: 12, color: '#444', lineHeight: 1.6, margin: '4px 0' };
+const liStyle: React.CSSProperties = { fontSize: 12, color: '#444', lineHeight: 1.6, marginBottom: 4 };
+const codeStyle: React.CSSProperties = { background: '#f4f4f4', padding: '1px 4px', borderRadius: 3, fontSize: 11 };
+
+export function SyncHelpModal({ onClose, initialAnchor }: Props): React.ReactElement {
+  const bodyRef = useRef<HTMLDivElement>(null);
+
+  useEffect(() => {
+    if (!initialAnchor) return;
+    const el = bodyRef.current?.querySelector(`#${initialAnchor}`);
+    if (el) el.scrollIntoView({ behavior: 'auto', block: 'start' });
+  }, [initialAnchor]);
+
+  // Escape key 로 닫기.
+  useEffect(() => {
+    function onKey(e: KeyboardEvent) {
+      if (e.key === 'Escape') onClose();
+    }
+    document.addEventListener('keydown', onKey);
+    return () => document.removeEventListener('keydown', onKey);
+  }, [onClose]);
+
+  return (
+    <div style={overlayStyle} onClick={onClose}>
+      <div ref={bodyRef} style={modalStyle} onClick={(e) => e.stopPropagation()}>
+        <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>
+          <h3 style={{ margin: 0, fontSize: 16 }}>동기화 도움말</h3>
+          <button onClick={onClose} aria-label="닫기" style={{ background: 'none', border: 'none', fontSize: 18, cursor: 'pointer', color: '#888' }}>×</button>
+        </div>
+
+        <section id="main-conflict" style={sectionStyle}>
+          <h4 style={h4Style}>1. 충돌 해결 (직접 결정해야 하는 일)</h4>
+          <p style={pStyle}>같은 노트를 두 기기에서 동시에 수정하면 어느 쪽을 남길지 Inkling 이 자동으로 결정할 수 없습니다. 이때 "충돌 해결…" 버튼이 활성화되고, 노트별로 "내 것 사용" 또는 "원격 사용" 을 골라주시면 됩니다.</p>
+
+          <p style={{ ...pStyle, marginTop: 10, fontWeight: 600 }}>편집/편집 — 가장 흔한 경우</p>
+          <ul style={{ paddingLeft: 18, margin: '4px 0' }}>
+            <li style={liStyle}>두 기기에서 같은 노트 본문 수정 → 양 텍스트가 ConflictModal 에 좌우로 나란히 표시</li>
+            <li style={liStyle}>결정 트리: 어느 쪽 변경이 더 새롭고 완전한지 비교 → 더 나은 쪽 선택</li>
+            <li style={liStyle}>둘 다 보존하려면? 현재 'both' 미지원 — 한쪽 선택 후 사후 수동 병합 (다른 쪽 텍스트 메모 → 모달 닫고 노트 편집)</li>
+          </ul>
+
+          <p style={{ ...pStyle, marginTop: 10, fontWeight: 600 }}>삭제/편집</p>
+          <ul style={{ paddingLeft: 18, margin: '4px 0' }}>
+            <li style={liStyle}>한쪽에서 trash 처리, 다른 쪽에서 같은 노트 본문 수정</li>
+            <li style={liStyle}>"삭제가 의도였다" → 원격 사용 (trash 측 적용)</li>
+            <li style={liStyle}>"수정이 더 중요" → 내 것 사용 (편집 측 적용 = trash 취소)</li>
+          </ul>
+
+          <p style={{ ...pStyle, marginTop: 10, fontWeight: 600 }}>AI 결과 충돌</p>
+          <ul style={{ paddingLeft: 18, margin: '4px 0' }}>
+            <li style={liStyle}>양 기기에서 AI 자동 처리 결과 (태그 / 주제 / 요약) 가 다름</li>
+            <li style={liStyle}>대부분 어느 쪽이든 무관 → 한쪽 선택 후 AI 재실행 권장 (가장 최신 모델 결과로 통일)</li>
+          </ul>
+        </section>
+
+        <section id="auto" style={sectionStyle}>
+          <h4 style={h4Style}>2. 자동으로 처리되는 일</h4>
+          <p style={pStyle}>아래 동작은 Inkling 이 알아서 처리합니다. 충돌이 없으면 사용자가 신경 쓸 일은 없습니다.</p>
+          <ul style={{ paddingLeft: 18, margin: '4px 0' }}>
+            <li style={liStyle}><b>원격 변경 먼저 받아오기</b>: 동기화를 시작하면 다른 기기가 올린 변경을 먼저 받아와 내 변경 위에 차곡차곡 올려놓습니다. 양쪽이 같은 줄을 건드리지 않으면 자동으로 진행됩니다.</li>
+            <li style={liStyle}><b>첫 동기화 순서</b>: 비어있는 원격 저장소에는 어느 기기든 먼저 올릴 수 있습니다. 두 번째 기기는 받아온 뒤 자동으로 합쳐집니다.</li>
+            <li style={liStyle}><b>업로드 거부 시 자동 재시도</b>: 다른 기기가 이미 변경을 올려둔 상태라 내 업로드가 막혀도, 받아오기 + 합치기 + 재시도가 자동으로 진행됩니다. 사용자가 개입할 일은 같은 위치를 양쪽이 동시에 수정한 경우에만 생깁니다.</li>
+            <li style={liStyle}><b>자동 동기화 주기</b>: 기본 30분 (설정에서 변경). 앱 종료 시에도 한 번 추가로 실행됩니다.</li>
+          </ul>
+        </section>
+
+        <section id="silent" style={sectionStyle}>
+          <h4 style={h4Style}>3. 모르고 넘어가기 쉬운 함정</h4>
+          <p style={pStyle}>아래 상황은 에러처럼 보이지 않지만 결과가 잘못 나올 수 있으니 미리 알아두는 것이 좋습니다.</p>
+          <ul style={{ paddingLeft: 18, margin: '4px 0' }}>
+            <li style={liStyle}><b>두 기기의 시각 어긋남</b>: 시계가 어긋나면 변경 순서가 뒤바뀌어 한쪽 수정이 묻힐 수 있습니다. macOS / Windows 모두 기본적으로 시각이 자동 동기화되니, 일부러 끄지 마세요.</li>
+            <li style={liStyle}><b>같은 노트를 두 기기에서 동시에 수정</b>: 충돌이 더 자주 발생합니다. 한 기기에서 작업 중이라면 다른 기기에서 같은 노트는 만지지 않는 편이 안전합니다.</li>
+            <li style={liStyle}><b>자동 동기화 실패는 조용히 지나갑니다</b>: 주기적 동기화가 실패해도 알림 토스트는 뜨지 않습니다. 마지막 동기화 시각과 결과는 설정 페이지에서 확인할 수 있으니, 주 1회 정도 점검을 권장합니다.</li>
+          </ul>
+        </section>
+
+        <section id="setup" style={sectionStyle}>
+          <h4 style={h4Style}>4. Setup / 인증 (troubleshoot)</h4>
+          <p style={{ ...pStyle, fontWeight: 600 }}>URL 형식 (둘 중 하나)</p>
+          <ul style={{ paddingLeft: 18, margin: '4px 0' }}>
+            <li style={liStyle}>SSH: <code style={codeStyle}>git@host:user/repo.git</code></li>
+            <li style={liStyle}>HTTPS: <code style={codeStyle}>https://host/user/repo.git</code></li>
+            <li style={liStyle}>잘못된 형식: <code style={codeStyle}>git@https://...</code> 같은 혼합 형식 ✗</li>
+          </ul>
+
+          <p style={{ ...pStyle, fontWeight: 600, marginTop: 10 }}>인증</p>
+          <ul style={{ paddingLeft: 18, margin: '4px 0' }}>
+            <li style={liStyle}>SSH: 기기에 SSH key 등록 + 원격에 public key 추가</li>
+            <li style={liStyle}>HTTPS: OS credential helper (Windows Credential Manager / macOS Keychain) 가 첫 push 시 token 입력받아 저장. 매 push 마다 재입력 X</li>
+          </ul>
+
+          <p style={{ ...pStyle, fontWeight: 600, marginTop: 10 }}>"연결 테스트" 실패 시</p>
+          <ul style={{ paddingLeft: 18, margin: '4px 0' }}>
+            <li style={liStyle}>네트워크: 원격 host 에 브라우저로 접속해 응답 확인</li>
+            <li style={liStyle}>인증: 위 인증 절차 점검</li>
+            <li style={liStyle}>URL: 형식 (SSH/HTTPS) + 오타 점검</li>
+          </ul>
+
+          <p style={{ ...pStyle, fontWeight: 600, marginTop: 10 }}>재설정</p>
+          <ul style={{ paddingLeft: 18, margin: '4px 0' }}>
+            <li style={liStyle}>URL 변경 시 설정 → 동기화 저장소에서 새 URL 입력 → 저장. 내부적으로 <code style={codeStyle}>git remote set-url origin</code> 자동 처리</li>
+          </ul>
+        </section>
+      </div>
+    </div>
+  );
+}

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

@@ -1,6 +1,8 @@
 import React, { useEffect, useState } from 'react';
 import { z } from 'zod';
 import { inboxApi } from '../../api.js';
+import { VisionSection } from './VisionSection.js';
+import { SectionIntro } from './SectionIntro.js';
 
 const endpointSchema = z.string().url();
 
@@ -77,6 +79,10 @@ export function AiProviderSection(): React.ReactElement {
 
   return (
     <div>
+      <SectionIntro>
+        메모를 자동으로 정리하는 AI 제공자입니다. Inkling 은 기본적으로 로컬 Ollama 를 사용해
+        데이터가 기기 밖으로 나가지 않게 합니다. 사용할 모델과 접속 주소를 여기서 지정합니다.
+      </SectionIntro>
       {/* v0.2.9 Cut B Task 15 — AI 자동 처리 토글 (가장 위, 스위치 의미가 가장 큰 결정) */}
       {aiEnabled !== null && (
         <label style={{ display: 'flex', gap: 8, alignItems: 'center', marginBottom: 12, fontSize: 13 }}>
@@ -192,6 +198,7 @@ export function AiProviderSection(): React.ReactElement {
       {recheckResult && (
         <div style={{ fontSize: 12, marginTop: 8 }}>{recheckResult}</div>
       )}
+      <VisionSection />
     </div>
   );
 }

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

@@ -1,6 +1,7 @@
 import React, { useEffect, useState } from 'react';
 import type { AutostartResponse } from '@shared/types';
 import { inboxApi } from '../../api.js';
+import { SectionIntro } from './SectionIntro.js';
 
 export function AutostartSection(): React.ReactElement {
   const [data, setData] = useState<AutostartResponse | null>(null);
@@ -31,14 +32,19 @@ export function AutostartSection(): React.ReactElement {
   }
 
   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);
+  // withArgs vs noArgs 의 openAtLogin 불일치는 양 플랫폼에서 진짜 mismatch 시그널.
+  // executableWillLaunchAtLogin 은 Win 에서만 신뢰 — macOS 13+ SMAppService API 는
+  // LoginItems 에 등록되어 있어도 unsigned/Electron 앱에 대해 false 를 자주 반환해
+  // false positive 가 발생함. macOS 는 이 신호를 mismatch 판정에서 제외.
+  const willLaunchSignal = d.platform === 'win32' && data.openAtLogin && !d.withArgs.executableWillLaunchAtLogin;
+  const mismatch = d.withArgs.openAtLogin !== d.noArgs.openAtLogin || willLaunchSignal;
 
   return (
     <div>
+      <SectionIntro>
+        시스템에 로그인하면 Inkling 이 백그라운드로 함께 시작합니다. 메인 창은 뜨지 않고,
+        Cmd+Shift+J (macOS) / Ctrl+Shift+J (Windows) 로 필요할 때 불러와 쓰시면 됩니다.
+      </SectionIntro>
       <label style={{ display: 'flex', gap: 8, alignItems: 'center', fontSize: 13 }}>
         <input type="checkbox" checked={data.openAtLogin} onChange={onToggle} />
         앱 시작 시 자동으로 실행

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

@@ -1,5 +1,6 @@
 import React, { useState } from 'react';
 import { inboxApi } from '../../api.js';
+import { SectionIntro } from './SectionIntro.js';
 
 export function BackupSection(): React.ReactElement {
   const [status, setStatus] = useState<string | null>(null);
@@ -14,6 +15,10 @@ export function BackupSection(): React.ReactElement {
 
   return (
     <div style={{ display: 'flex', flexDirection: 'column', gap: 8 }}>
+      <SectionIntro>
+        메모와 첨부 이미지를 안전하게 백업하거나 다른 기기로 옮길 때 사용합니다. 자동 백업은 매일
+        앱 종료 시 1회 실행되고, 여기서는 필요할 때 수동으로 실행할 수 있습니다.
+      </SectionIntro>
       <button onClick={() => run('지금 백업', () => inboxApi.runBackup())}>지금 백업</button>
       <button onClick={() => run('내보내기', () => inboxApi.runExport())}>내보내기...</button>
       <button onClick={() => run('백업에서 복원', () => inboxApi.runImport())}>백업에서 복원...</button>

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

@@ -1,5 +1,6 @@
 import React, { useEffect, useState } from 'react';
 import { inboxApi } from '../../api.js';
+import { SectionIntro } from './SectionIntro.js';
 
 interface AppInfo {
   version: string;
@@ -20,6 +21,9 @@ export function InfoSection(): React.ReactElement {
 
   return (
     <div>
+      <SectionIntro>
+        문제 보고나 호환성 확인이 필요할 때 참고하실 정보입니다.
+      </SectionIntro>
       <dl style={{ fontSize: 12, lineHeight: 1.6 }}>
         <dt style={{ fontWeight: 600 }}>버전</dt>
         <dd>{info.version}</dd>

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

@@ -0,0 +1,12 @@
+import React from 'react';
+
+interface Props { children: React.ReactNode; }
+
+/** Settings page 각 section 상단에 표시되는 간단한 설명 paragraph. */
+export function SectionIntro({ children }: Props): React.ReactElement {
+  return (
+    <p style={{ fontSize: 12, color: '#666', lineHeight: 1.6, margin: '0 0 12px 0' }}>
+      {children}
+    </p>
+  );
+}

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

@@ -0,0 +1,168 @@
+import React, { useEffect, useState } from 'react';
+import { inboxApi } from '../../api.js';
+import type { SyncStatusSnapshot } from '@shared/types';
+import { ConflictModal } from '../ConflictModal.js';
+import { SyncHelpModal, type SyncHelpAnchor } from '../SyncHelpModal.js';
+import { SectionIntro } from './SectionIntro.js';
+
+export function SyncSection(): React.ReactElement {
+  const [url, setUrl] = useState('');
+  const [draftUrl, setDraftUrl] = useState('');
+  const [autoEnabled, setAutoEnabled] = useState(true);
+  const [intervalMin, setIntervalMin] = useState(30);
+  const [status, setStatus] = useState<SyncStatusSnapshot | null>(null);
+  const [busy, setBusy] = useState<'save' | 'test' | 'sync' | null>(null);
+  const [feedback, setFeedback] = useState<string | null>(null);
+  const [showConflict, setShowConflict] = useState(false);
+  const [showHelp, setShowHelp] = useState<{ open: boolean; anchor?: SyncHelpAnchor }>({ open: false });
+
+  useEffect(() => {
+    void (async () => {
+      const s = await inboxApi.getSettings();
+      const u = s.sync_repo_url ?? '';
+      setUrl(u);
+      setDraftUrl(u);
+      setAutoEnabled(s.sync_auto_enabled ?? true);
+      setIntervalMin(s.sync_interval_min ?? 30);
+      setStatus(await inboxApi.getSyncStatus());
+    })();
+  }, []);
+
+  async function onSaveUrl() {
+    setBusy('save');
+    setFeedback(null);
+    const r = await inboxApi.configureSync(draftUrl.trim() === '' ? null : draftUrl.trim());
+    setBusy(null);
+    if (r.ok) {
+      setUrl(draftUrl.trim());
+      setFeedback('저장되었습니다');
+    } else {
+      setFeedback(`저장 실패: ${r.reason}`);
+    }
+  }
+
+  async function onTestConnection() {
+    setBusy('test');
+    setFeedback(null);
+    const r = await inboxApi.testSyncConnection();
+    setBusy(null);
+    setFeedback(r.ok ? '연결 성공' : `연결 실패: ${r.reason}`);
+  }
+
+  async function onToggleAuto(next: boolean) {
+    await inboxApi.setSyncAutoEnabled(next);
+    setAutoEnabled(next);
+  }
+
+  async function onChangeInterval(value: number) {
+    if (!Number.isInteger(value) || value < 5) return;
+    const r = await inboxApi.setSyncIntervalMin(value);
+    if (r.ok) setIntervalMin(value);
+  }
+
+  const conflictCount = status?.lastResult?.conflicts?.length ?? 0;
+
+  return (
+    <section style={{ marginTop: 24 }}>
+      <h3 style={{ fontSize: 14, marginBottom: 8 }}>동기화 저장소</h3>
+      <SectionIntro>
+        Git 저장소를 통해 여러 기기 간 메모를 동기화합니다. 단일 기기에서만 사용하시면 URL 을
+        비워두셔도 됩니다. 자동 동기화 주기와 충돌 처리는 아래에서 설정합니다.
+      </SectionIntro>
+
+      <div style={{ display: 'flex', gap: 6, marginBottom: 8 }}>
+        <input
+          type="text"
+          aria-label="저장소 URL"
+          placeholder="git@host:user/inkling-notes.git"
+          value={draftUrl}
+          onChange={(e) => setDraftUrl(e.target.value)}
+          style={{ flex: 1, fontSize: 12, padding: '4px 8px', border: '1px solid #ccc', borderRadius: 4 }}
+        />
+        <button onClick={() => { void onSaveUrl(); }} disabled={busy !== null} style={btnStyle()}>
+          {busy === 'save' ? '저장 중…' : '저장'}
+        </button>
+        <button onClick={() => { void onTestConnection(); }} disabled={busy !== null || url.trim() === ''} style={btnStyle()}>
+          {busy === 'test' ? '확인 중…' : '연결 테스트'}
+        </button>
+        <button onClick={() => setShowHelp({ open: true })} style={btnStyle()}>
+          도움말
+        </button>
+      </div>
+
+      {feedback !== null && (
+        <div style={{ fontSize: 12, color: '#444', marginBottom: 8 }}>{feedback}</div>
+      )}
+
+      {url.trim() !== '' && (
+        <>
+          <div style={{ fontSize: 12, color: '#666', marginBottom: 8 }}>
+            마지막 sync: {status?.lastAt ?? '없음'} {status?.lastResult?.ok === false && status?.lastResult?.reason !== 'conflict' && (
+              <span style={{ color: '#a55' }}> ({status.lastResult.reason})</span>
+            )}
+          </div>
+
+          <label style={{ display: 'flex', alignItems: 'center', gap: 6, fontSize: 12, marginBottom: 6 }}>
+            <input
+              type="checkbox"
+              checked={autoEnabled}
+              onChange={(e) => { void onToggleAuto(e.target.checked); }}
+            />
+            자동 sync 사용
+          </label>
+
+          <label style={{ display: 'flex', alignItems: 'center', gap: 6, fontSize: 12, marginBottom: 8 }}>
+            interval:
+            <input
+              type="number"
+              aria-label="sync interval (분)"
+              min={5}
+              value={intervalMin}
+              onChange={(e) => { void onChangeInterval(Number.parseInt(e.target.value, 10)); }}
+              disabled={!autoEnabled}
+              style={{ width: 60, fontSize: 12, padding: '2px 4px' }}
+            />
+            분
+          </label>
+
+          {conflictCount > 0 && (
+            <div style={{ marginTop: 8 }}>
+              <button onClick={() => setShowConflict(true)} style={btnStyle()}>
+                충돌 해결… ({conflictCount}건)
+              </button>
+            </div>
+          )}
+
+          {showConflict && (
+            <ConflictModal
+              onClose={() => setShowConflict(false)}
+              onResolved={async () => {
+                setStatus(await inboxApi.getSyncStatus());
+              }}
+              onOpenHelp={(anchor) => setShowHelp({ open: true, anchor })}
+            />
+          )}
+        </>
+      )}
+
+      {showHelp.open && (
+        <SyncHelpModal
+          onClose={() => setShowHelp({ open: false })}
+          initialAnchor={showHelp.anchor}
+        />
+      )}
+    </section>
+  );
+}
+
+function btnStyle(): React.CSSProperties {
+  return {
+    background: '#0a4b80',
+    color: '#fff',
+    border: 'none',
+    cursor: 'pointer',
+    fontSize: 12,
+    padding: '4px 10px',
+    borderRadius: 4
+  };
+}

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

@@ -0,0 +1,86 @@
+import React, { useEffect, useState } from 'react';
+import { inboxApi } from '../../api.js';
+import { SectionIntro } from './SectionIntro.js';
+
+export function VisionSection(): React.ReactElement {
+  const [models, setModels] = useState<string[]>([]);
+  const [at, setAt] = useState<string | null>(null);
+  const [selected, setSelected] = useState<string | null>(null);
+  const [busy, setBusy] = useState<'select' | 'refresh' | null>(null);
+  const [feedback, setFeedback] = useState<string | null>(null);
+
+  async function load() {
+    const r = await inboxApi.getVisionModels();
+    setModels(r.models);
+    setAt(r.at);
+    setSelected(r.selected);
+  }
+
+  useEffect(() => {
+    void load();
+  }, []);
+
+  async function onSelect(value: string) {
+    const next = value === '' ? null : value;
+    setBusy('select');
+    setFeedback(null);
+    await inboxApi.setVisionModel(next);
+    setSelected(next);
+    setBusy(null);
+  }
+
+  async function onRefresh() {
+    setBusy('refresh');
+    setFeedback(null);
+    const r = await inboxApi.refreshVisionCache();
+    setBusy(null);
+    if (r.ok) {
+      await load();
+      setFeedback(`감지 완료 (${r.models.length}개)`);
+    } else {
+      setFeedback(`감지 실패: ${r.reason}`);
+    }
+  }
+
+  return (
+    <section style={{ marginTop: 16 }}>
+      <h4 style={{ fontSize: 13, marginBottom: 6 }}>이미지 분석 모델 (선택사항)</h4>
+      <SectionIntro>
+        첨부 이미지를 함께 분석할 vision 지원 모델입니다. 텍스트용 모델과 별도로 지정할 수 있고,
+        미지정 시 이미지 첨부 메모는 텍스트만 정리됩니다.
+      </SectionIntro>
+      <div style={{ display: 'flex', gap: 6, alignItems: 'center', marginBottom: 6 }}>
+        <select
+          aria-label="이미지 분석 모델"
+          value={selected ?? ''}
+          onChange={(e) => { void onSelect(e.target.value); }}
+          disabled={busy !== null}
+          style={{ flex: 1, fontSize: 12, padding: '4px 8px', border: '1px solid #ccc', borderRadius: 4 }}
+        >
+          <option value="">(비활성)</option>
+          {models.map((m) => <option key={m} value={m}>{m}</option>)}
+        </select>
+        <button
+          onClick={() => { void onRefresh(); }}
+          disabled={busy !== null}
+          style={{ background: '#0a4b80', color: '#fff', border: 'none', cursor: 'pointer', fontSize: 12, padding: '4px 10px', borderRadius: 4 }}
+        >
+          {busy === 'refresh' ? '감지 중…' : '다시 감지'}
+        </button>
+      </div>
+      {at !== null && (
+        <div style={{ fontSize: 11, color: '#888' }}>
+          마지막 감지: {new Date(at).toLocaleString('ko-KR')}
+        </div>
+      )}
+      {feedback !== null && (
+        <div style={{ fontSize: 11, color: '#444', marginTop: 4 }}>{feedback}</div>
+      )}
+      {models.length === 0 && (
+        <div style={{ fontSize: 11, color: '#aaa', marginTop: 4 }}>
+          감지된 모델 없음. Ollama 에 vision 모델을 설치하고 "다시 감지" 클릭.
+        </div>
+      )}
+    </section>
+  );
+}

src/renderer/inbox/index.html

@@ -2,7 +2,7 @@
 <html lang="ko">
   <head>
     <meta charset="UTF-8" />
-    <meta http-equiv="Content-Security-Policy" content="default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data: blob: file:" />
+    <meta http-equiv="Content-Security-Policy" content="default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data: blob: file: inkling-media:" />
     <title>Inkling</title>
     <style>
       body { margin: 0; font-family: system-ui, sans-serif; background: #f5f5f7; color: #111; }

src/renderer/inbox/store.ts

@@ -1,18 +1,24 @@
 import { create } from 'zustand';
-import type { Note, WeeklyContinuity } from '@shared/types';
-import { inboxApi } from './api.js';
+import type { Note, NoteStatus, Notebook, PromotionCandidate, ReviewAggregate, WeeklyContinuity, BatchClassifyResult } from '@shared/types';
+import { inboxApi, notebookApi } from './api.js';
 import { nextKstMidnightMs } from '@shared/util/kstDate.js';
 
+function toTitleCase(s: string): string {
+  return s.split('-').map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
+}
+
 export { selectFilteredNotes } from './selectFilteredNotes.js';
 
-// v0.2.9 Cut B Task 4 — 4탭 view enum + settings.
-// 'inbox' = active, 'completed'/'archived' = NoteStatus 그대로, 'trash' = trashed (mirror), 'settings' = SettingsPage.
-export type InboxView = 'inbox' | 'completed' | 'archived' | 'trash' | 'settings';
+// v0.2.9 Cut B Task 4 — 3탭 view enum + settings.
+// v0.4 Task 16 — 'archived' view 제거 (NoteStatus 에서 archived 삭제됨).
+// 'inbox' = active, 'completed' = NoteStatus 그대로, 'trash' = trashed (mirror), 'settings' = SettingsPage.
+export type InboxView =
+  | 'inbox' | 'completed' | 'trash' | 'settings'
+  | 'review-daily' | 'review-weekly' | 'review-monthly';
 
 export interface InboxCounts {
   active: number;
   completed: number;
-  archived: number;
   trashed: number;
 }
 
@@ -39,6 +45,20 @@ interface InboxState {
   // v0.2.9 Cut B Task 14 — AI 비활성 모드에서는 OllamaBanner/FailedBanner render skip.
   // 기본 true (기존 사용자 무영향). loadInitial / refreshMeta 가 settings 로드.
   ai_enabled: boolean;
+  // v0.2.11 Cut D — FTS5 search + review aggregate state.
+  searchQuery: string;
+  searchResults: Note[] | null;  // null = 검색 안 한 상태
+  reviewData: ReviewAggregate | null;
+  // v0.4 — Notebook sidebar state.
+  notebooks: Notebook[];
+  selectedNotebookId: string | null;
+  sidebarVisible: boolean;
+  sidebarWidth: number;
+  // v0.4 Task 11 — promotion candidates (dismissed/snoozed 필터 적용 후 목록).
+  promotionCandidates: PromotionCandidate[];
+  // v0.4 T5 — AI batch classify state.
+  batchClassifyResult: BatchClassifyResult | null;
+  batchClassifying: boolean;
   loadInitial: () => Promise<void>;
   refreshMeta: () => Promise<void>;
   upsertNote: (note: Note) => void;
@@ -46,13 +66,12 @@ interface InboxState {
   setTagFilter: (tag: string | null) => void;
   setShowSettings: (open: boolean) => void;
   setView: (view: InboxView) => void;
-  loadByView: (view: 'completed' | 'archived' | 'trash') => Promise<void>;
+  loadByView: (view: 'inbox' | 'completed' | 'trash') => Promise<void>;
   toggleShowTrash: () => Promise<void>;
   loadTrash: () => Promise<void>;
   restoreNote: (id: string) => Promise<void>;
   permanentDeleteNote: (id: string) => Promise<void>;
   emptyTrash: () => Promise<void>;
-  loadExpired: () => Promise<void>;
   trashExpiredBatch: (ids: string[]) => Promise<void>;
   snoozeExpired: () => void;
   recheckOllama: () => Promise<void>;
@@ -61,6 +80,31 @@ interface InboxState {
   openRecall: (id: string) => Promise<void>;
   dismissRecallNote: (id: string) => Promise<void>;
   snoozeRecall: () => Promise<void>;
+  // v0.2.11 Cut D — search + review actions.
+  setSearchQuery: (q: string) => void;
+  // v0.4 Task 18 — scope 토글. notebookId 전달 시 해당 notebook 안 검색, undefined 시 전체 검색.
+  searchNotes: (q: string, opts?: { notebookId?: string }) => Promise<void>;
+  clearSearch: () => void;
+  loadReview: (period: 'daily' | 'weekly' | 'monthly') => Promise<void>;
+  // v0.4 — Notebook actions.
+  loadNotebooks: () => Promise<void>;
+  selectNotebook: (id: string) => void;
+  createNotebook: (name: string, color?: string) => Promise<{ ok: boolean; reason?: string }>;
+  renameNotebook: (id: string, name: string) => Promise<{ ok: boolean; reason?: string }>;
+  setNotebookColor: (id: string, color: string | null) => Promise<void>;
+  deleteNotebook: (id: string) => Promise<{ ok: boolean; reason?: string }>;
+  moveNoteToNotebook: (noteId: string, notebookId: string) => Promise<void>;
+  reorderNotebook: (id: string, direction: 'up' | 'down') => Promise<void>;
+  toggleSidebar: () => void;
+  // v0.4 Task 11 — promotion candidate actions.
+  loadPromotionCandidates: () => Promise<void>;
+  acceptPromotion: (tag: string, customName: string, color: string | undefined) => Promise<void>;
+  snoozePromotion: () => Promise<void>;
+  dismissPromotion: (tag: string) => Promise<void>;
+  // v0.4 T5 — AI batch classify actions.
+  runBatchClassify: () => Promise<void>;
+  clearBatchClassify: () => void;
+  acceptBatchAssignments: (accepted: Array<{ noteId: string; notebookId: string }>) => Promise<void>;
 }
 
 const emptyContinuity: WeeklyContinuity = {
@@ -75,7 +119,7 @@ export const useInbox = create<InboxState>((set, get) => ({
   showTrash: false,
   showSettings: false,
   view: 'inbox',
-  counts: { active: 0, completed: 0, archived: 0, trashed: 0 },
+  counts: { active: 0, completed: 0, trashed: 0 },
   continuity: emptyContinuity,
   pendingCount: 0,
   ollamaStatus: { ok: true },
@@ -88,67 +132,136 @@ export const useInbox = create<InboxState>((set, get) => ({
   recallCandidate: null,
   recallSnoozeUntilMs: null,
   ai_enabled: true,
+  searchQuery: '',
+  searchResults: null,
+  reviewData: null,
+  notebooks: [],
+  selectedNotebookId: null,
+  sidebarVisible: true,
+  sidebarWidth: 240,
+  promotionCandidates: [],
+  batchClassifyResult: null,
+  batchClassifying: false,
   async loadInitial() {
+    // v0.3.8 — IPC 실패 시 loading=true 영구 stuck 방지. catch 로 reset.
     set({ loading: true });
-    const [notes, continuity, pendingCount, ollamaStatus, todayCount, trashCount, expiredCandidates, failedCount, recallCandidate, counts, settings] = await Promise.all([
-      inboxApi.listNotes({ limit: 50 }),
-      inboxApi.getContinuity(),
-      inboxApi.getPendingCount(),
-      inboxApi.getOllamaStatus(),
-      inboxApi.getTodayCount(),
-      inboxApi.getTrashCount(),
-      inboxApi.listExpired(),
-      inboxApi.getFailedCount(),
-      inboxApi.listRecallCandidate(),
-      inboxApi.countsByStatus(),
-      inboxApi.getSettings()
-    ]);
-    set({ notes, continuity, pendingCount, ollamaStatus, todayCount, trashCount, expiredCandidates, failedCount, recallCandidate, counts, ai_enabled: settings.ai_enabled ?? true, loading: false });
+    try {
+      const notebookId = get().selectedNotebookId ?? undefined;
+      const [notes, continuity, pendingCount, ollamaStatus, todayCount, trashCount, expiredCandidates, failedCount, recallCandidate, counts, settings] = await Promise.all([
+        // inbox 탭은 status='active' 만 표시 — loadByView('inbox') 와 동일 path 로 일관성 확보.
+        // listNotes 는 deleted_at IS NULL 만 필터 (= active+completed+archived 혼재) 이라 부정확.
+        inboxApi.listByStatus('active', { limit: 50, notebookId }),
+        inboxApi.getContinuity(),
+        inboxApi.getPendingCount(),
+        inboxApi.getOllamaStatus(),
+        inboxApi.getTodayCount(),
+        inboxApi.getTrashCount(),
+        inboxApi.listExpired(),
+        inboxApi.getFailedCount(),
+        inboxApi.listRecallCandidate(),
+        inboxApi.countsByStatus({ notebookId }),
+        inboxApi.getSettings()
+      ]);
+      set({
+        notes, continuity, pendingCount, ollamaStatus, todayCount, trashCount, expiredCandidates,
+        failedCount, recallCandidate, counts,
+        ai_enabled: settings.ai_enabled ?? true,
+        sidebarVisible: settings.sidebar_visible ?? true,
+        sidebarWidth: settings.sidebar_width ?? 240,
+        loading: false
+      });
+    } catch (e) {
+      // 첫 launch 의 IPC 실패 (DB migration 실패 / main process 비정상) 시 무한 loading 회피.
+      // 빈 데이터로 진입하면 사용자가 캡처 시도 → 실제 fail 이 표면화 → 재시도 가능.
+      console.error('[inbox] loadInitial failed', e);
+      set({ loading: false });
+    }
   },
   async refreshMeta() {
-    const [continuity, pendingCount, ollamaStatus, todayCount, trashCount, expiredCandidates, failedCount, recallCandidate, counts, settings] = await Promise.all([
-      inboxApi.getContinuity(),
-      inboxApi.getPendingCount(),
-      inboxApi.getOllamaStatus(),
-      inboxApi.getTodayCount(),
-      inboxApi.getTrashCount(),
-      inboxApi.listExpired(),
-      inboxApi.getFailedCount(),
-      inboxApi.listRecallCandidate(),
-      inboxApi.countsByStatus(),
-      inboxApi.getSettings()
-    ]);
-    set({ continuity, pendingCount, ollamaStatus, todayCount, trashCount, expiredCandidates, failedCount, recallCandidate, counts, ai_enabled: settings.ai_enabled ?? true });
+    try {
+      const notebookId = get().selectedNotebookId ?? undefined;
+      const [continuity, pendingCount, ollamaStatus, todayCount, trashCount, expiredCandidates, failedCount, recallCandidate, counts, settings] = await Promise.all([
+        inboxApi.getContinuity(),
+        inboxApi.getPendingCount(),
+        inboxApi.getOllamaStatus(),
+        inboxApi.getTodayCount(),
+        inboxApi.getTrashCount(),
+        inboxApi.listExpired(),
+        inboxApi.getFailedCount(),
+        inboxApi.listRecallCandidate(),
+        inboxApi.countsByStatus({ notebookId }),
+        inboxApi.getSettings()
+      ]);
+      set({ continuity, pendingCount, ollamaStatus, todayCount, trashCount, expiredCandidates, failedCount, recallCandidate, counts, ai_enabled: settings.ai_enabled ?? true });
+    } catch (e) {
+      // refreshMeta 는 background poll/event 에서 자주 호출 → fail 무시 (다음 호출에 회복).
+      console.error('[inbox] refreshMeta failed', e);
+    }
   },
   upsertNote(note) {
-    // trashCount 는 server-authoritative. trashNotes 가 cache-loaded (showTrash=true) 일
-    // 때만 trashCount 를 local recompute. 그 외엔 server 값 (refreshMeta) 보존.
-    const showTrash = get().showTrash;
-    if (note.deletedAt !== null) {
-      // trash 노트: notes 에서 제거 + trashNotes 에 upsert
-      const cleanNotes = get().notes.filter((n) => n.id !== note.id);
-      const ti = get().trashNotes.findIndex((n) => n.id === note.id);
-      const nextTrash = get().trashNotes.slice();
-      if (ti >= 0) nextTrash[ti] = note;
+    // v0.3.8 — status 가 current view 와 매칭될 때만 notes 에 유지. 그 외엔 제거.
+    // 이전 구현은 trashed 외 모든 status 를 notes 에 누적 → 사용자가 inbox view 에서
+    // 완료/보관 으로 옮긴 노트가 list 에 잔류하는 버그. push-based (setStatus 도 emit) 로
+    // 모든 status 전이가 upsertNote 를 거치므로 view-aware filter 가 필수.
+    //
+    // trashCount/trashNotes 는 server-authoritative. trashNotes 가 cache-loaded
+    // (view='trash') 일 때만 trashCount 를 local recompute. 그 외엔 server 값
+    // (refreshMeta) 보존. searchResults 도 별도로 갱신 (status 변경 시 list 에서 제거).
+    const state = get();
+    const view = state.view;
+    const showTrash = state.showTrash;
+    const viewStatus: 'active' | 'completed' | 'trashed' | null =
+      view === 'inbox' ? 'active' :
+      view === 'completed' ? 'completed' :
+      view === 'trash' ? 'trashed' : null;
+
+    // trashNotes — note.status='trashed' 면 upsert, 아니면 제거.
+    const cleanTrash = state.trashNotes.filter((n) => n.id !== note.id);
+    let nextTrash = cleanTrash;
+    if (note.status === 'trashed') {
+      const ti = state.trashNotes.findIndex((n) => n.id === note.id);
+      nextTrash = cleanTrash.slice();
+      if (ti >= 0) nextTrash.splice(ti, 0, note);
       else nextTrash.unshift(note);
-      set({
-        notes: cleanNotes,
-        trashNotes: nextTrash,
-        ...(showTrash ? { trashCount: nextTrash.length } : {})
-      });
-    } else {
-      // active 노트: trashNotes 에서 제거 + notes 에 upsert (restore 케이스 포함)
-      const cleanTrash = get().trashNotes.filter((n) => n.id !== note.id);
-      const i = get().notes.findIndex((n) => n.id === note.id);
-      const nextNotes = get().notes.slice();
-      if (i >= 0) nextNotes[i] = note;
-      else nextNotes.unshift(note);
-      set({
-        notes: nextNotes,
-        trashNotes: cleanTrash,
-        ...(showTrash ? { trashCount: cleanTrash.length } : {})
-      });
     }
+
+    // notes — current view 의 status 와 매칭되는 경우만 유지/upsert.
+    // viewStatus=null (review/settings/검색) 이면 notes 직접 렌더 안 함 → 갱신 skip.
+    const cleanNotes = state.notes.filter((n) => n.id !== note.id);
+    let nextNotes = state.notes;
+    if (viewStatus !== null) {
+      if (note.status === viewStatus) {
+        const i = state.notes.findIndex((n) => n.id === note.id);
+        nextNotes = cleanNotes.slice();
+        if (i >= 0) nextNotes.splice(i, 0, note);
+        else nextNotes.unshift(note);
+      } else {
+        nextNotes = cleanNotes;
+      }
+    }
+
+    // searchResults — null 아니면 동일 패턴으로 갱신 (status 가 current search status 와
+    // 안 맞으면 제거, 맞으면 upsert).
+    let nextSearch = state.searchResults;
+    if (state.searchResults !== null) {
+      const cleanSearch = state.searchResults.filter((n) => n.id !== note.id);
+      if (viewStatus === null || note.status === viewStatus) {
+        // search 가 active 한 view 가 review/settings 면 status filter 없음 → 모두 keep.
+        const i = state.searchResults.findIndex((n) => n.id === note.id);
+        nextSearch = cleanSearch.slice();
+        if (i >= 0) nextSearch.splice(i, 0, note);
+        else nextSearch.unshift(note);
+      } else {
+        nextSearch = cleanSearch;
+      }
+    }
+
+    set({
+      notes: nextNotes,
+      trashNotes: nextTrash,
+      searchResults: nextSearch,
+      ...(showTrash ? { trashCount: nextTrash.length } : {})
+    });
   },
   removeNote(id) {
     const cleanNotes = get().notes.filter((n) => n.id !== id);
@@ -169,23 +282,42 @@ export const useInbox = create<InboxState>((set, get) => ({
     else get().setView('inbox');
   },
   setView(view) {
+    // view 전환 시 검색/태그 필터 reset — 이전 view 의 필터가 새 view 에 잘못 적용되는 것 방지.
     set({
       view,
       showTrash: view === 'trash',
-      showSettings: view === 'settings'
+      showSettings: view === 'settings',
+      searchResults: null,
+      searchQuery: '',
+      tagFilter: null
     });
-    // settings/inbox 외 status view 면 해당 status fetch.
-    if (view === 'completed' || view === 'archived' || view === 'trash') {
+    // status view 면 해당 status fetch. inbox 도 포함 — 다른 탭에서 돌아올 때 notes 가
+    // 이전 status 로 stale 한 상태이므로 재로드 필요.
+    if (view === 'inbox' || view === 'completed' || view === 'trash') {
       void get().loadByView(view);
     }
+    // v0.2.11 Cut D — review-* view 진입 시 aggregate 로드.
+    if (view === 'review-daily') void get().loadReview('daily');
+    if (view === 'review-weekly') void get().loadReview('weekly');
+    if (view === 'review-monthly') void get().loadReview('monthly');
   },
   async loadByView(view) {
-    const status = view === 'trash' ? 'trashed' : view;
-    const notes = await inboxApi.listByStatus(status, { limit: 200 });
-    if (view === 'trash') {
-      set({ trashNotes: notes, trashCount: notes.length });
-    } else {
-      set({ notes });
+    // v0.3.8 — IPC 실패 시 stale 한 이전 view 의 notes 가 계속 노출되는 사고 방지.
+    // fail 시 빈 배열로 reset 해서 사용자에게 "비어있음" 으로 표시 (혼동 < stale).
+    const status =
+      view === 'trash' ? 'trashed' : view === 'inbox' ? 'active' : view;
+    const notebookId = get().selectedNotebookId ?? undefined;
+    try {
+      const notes = await inboxApi.listByStatus(status, { limit: 200, notebookId });
+      if (view === 'trash') {
+        set({ trashNotes: notes, trashCount: notes.length });
+      } else {
+        set({ notes });
+      }
+    } catch (e) {
+      console.error('[inbox] loadByView failed', view, e);
+      if (view === 'trash') set({ trashNotes: [] });
+      else set({ notes: [] });
     }
   },
   async toggleShowTrash() {
@@ -200,11 +332,12 @@ export const useInbox = create<InboxState>((set, get) => ({
   async restoreNote(id) {
     await inboxApi.restoreNote(id);
     // 낙관적 갱신: main 은 trash/restore 시 pushNoteUpdated 를 보내지 않음
-    // (현재 AiWorker.onUpdate 만 push). 자가 반영이 primary 메커니즘.
+    // (현재 AiWorker.onUpdate + setStatus 만 push). 자가 반영이 primary 메커니즘.
     // 전제: 호출 시점에 trashNotes 에 노트가 존재 (T14 trash view 한정 호출).
+    // v0.3.8 — status 도 'active' 로 함께 갱신. upsertNote 가 status='trashed' 만 trash 로 라우팅.
     const note = get().trashNotes.find((n) => n.id === id);
     if (note) {
-      get().upsertNote({ ...note, deletedAt: null });
+      get().upsertNote({ ...note, deletedAt: null, status: 'active' });
     }
   },
   async permanentDeleteNote(id) {
@@ -217,10 +350,6 @@ export const useInbox = create<InboxState>((set, get) => ({
       set({ trashNotes: [], trashCount: 0 });
     }
   },
-  async loadExpired() {
-    const expiredCandidates = await inboxApi.listExpired();
-    set({ expiredCandidates });
-  },
   async trashExpiredBatch(ids: string[]) {
     const r = await inboxApi.trashExpiredBatch(ids);
     if (!r.confirmed) return;
@@ -267,7 +396,183 @@ export const useInbox = create<InboxState>((set, get) => ({
     // snooze 는 적용하되 emit 만 skip. telemetry 누락 받아들임 (의도적).
     const candidate = get().recallCandidate;
     if (candidate) {
-      await inboxApi.emitRecallSnoozed(candidate.id);
+      inboxApi.emitRecallSnoozed(candidate.id);
     }
+  },
+  // v0.2.11 Cut D — FTS5 search + review aggregate actions.
+  setSearchQuery(q) {
+    set({ searchQuery: q });
+    if (q.trim().length === 0) set({ searchResults: null });
+  },
+  async searchNotes(q, opts) {
+    if (q.trim().length === 0) {
+      set({ searchResults: null });
+      return;
+    }
+    const view = get().view;
+    // 회고/설정 view 일 때는 status filter 무의미 → 그대로 전체 검색
+    const status = view === 'completed' || view === 'trash'
+      ? (view === 'trash' ? 'trashed' : view)
+      : view === 'inbox' ? 'active' : undefined;
+    try {
+      // v0.4 Task 18 — opts.notebookId 전달 시 해당 notebook 안 검색, undefined 시 전체 검색.
+      const searchOpts: { status?: NoteStatus; notebookId?: string } = status ? { status: status as NoteStatus } : {};
+      if (opts?.notebookId !== undefined) searchOpts.notebookId = opts.notebookId;
+      const r = await inboxApi.search(q, searchOpts);
+      set({ searchResults: r });
+    } catch (e) {
+      // FTS5 query parse error (special char 미escape) / IPC fail → 빈 결과로.
+      console.error('[inbox] searchNotes failed', e);
+      set({ searchResults: [] });
+    }
+  },
+  clearSearch() {
+    set({ searchQuery: '', searchResults: null });
+  },
+  async loadReview(period) {
+    try {
+      const data = await inboxApi.reviewAggregate(period);
+      set({ reviewData: data });
+    } catch (e) {
+      // review IPC fail 시 reviewData=null → ReviewView 의 "불러오는 중…" 영구 표시 회피.
+      // 빈 aggregate 로 set 해서 사용자에게 "0건" 표기.
+      console.error('[inbox] loadReview failed', period, e);
+      set({ reviewData: { totalCount: 0, tagCounts: [], dueProgress: { total: 0, passed: 0, pending: 0 }, recentNotes: [] } });
+    }
+  },
+  // v0.4 — Notebook actions.
+  async loadNotebooks() {
+    const notebooks = await notebookApi.list();
+    const current = get().selectedNotebookId;
+    // selectedNotebookId 가 null 이면 첫 notebook (가장 오래된 = 기본) 으로 설정.
+    const selectedNotebookId = current === null && notebooks.length > 0
+      ? notebooks[0]!.id
+      : current;
+    set({ notebooks, selectedNotebookId });
+  },
+  selectNotebook(id) {
+    set({ selectedNotebookId: id });
+    // v0.4 Task 19 — notebook 전환 시 list + counts 자동 갱신.
+    const v = get().view;
+    if (v === 'inbox' || v === 'completed' || v === 'trash') {
+      void get().loadByView(v);
+    }
+    void get().refreshMeta();
+  },
+  async createNotebook(name, color) {
+    const r = await notebookApi.create({ name, color });
+    if (r.ok) {
+      set({ notebooks: [...get().notebooks, r.notebook] });
+      return { ok: true };
+    }
+    return { ok: false, reason: r.reason };
+  },
+  async renameNotebook(id, name) {
+    const r = await notebookApi.rename(id, name);
+    if (r.ok) {
+      set({ notebooks: get().notebooks.map((n) => n.id === id ? { ...n, name } : n) });
+      return { ok: true };
+    }
+    return { ok: false, reason: r.reason };
+  },
+  async setNotebookColor(id, color) {
+    await notebookApi.setColor(id, color);
+    set({ notebooks: get().notebooks.map((n) => n.id === id ? { ...n, color } : n) });
+  },
+  async deleteNotebook(id) {
+    const r = await notebookApi.delete(id);
+    if (r.ok) {
+      const remaining = get().notebooks.filter((n) => n.id !== id);
+      const wasSelected = get().selectedNotebookId === id;
+      set({
+        notebooks: remaining,
+        selectedNotebookId: wasSelected ? (remaining[0]?.id ?? null) : get().selectedNotebookId
+      });
+      return { ok: true };
+    }
+    return { ok: false, reason: r.reason };
+  },
+  async moveNoteToNotebook(noteId, notebookId) {
+    await notebookApi.moveNote(noteId, notebookId);
+    await get().refreshMeta();
+  },
+  async reorderNotebook(id, direction) {
+    const r = await notebookApi.reorder(id, direction);
+    if (r.ok) {
+      await get().loadNotebooks();
+    }
+  },
+  toggleSidebar() {
+    const next = !get().sidebarVisible;
+    set({ sidebarVisible: next });
+    void inboxApi.setSidebarVisible(next);
+  },
+  // v0.4 Task 11 — promotion candidate actions.
+  async loadPromotionCandidates() {
+    try {
+      const [dismissed, snoozeUntil, raw] = await Promise.all([
+        inboxApi.getPromotionDismissedTags(),
+        inboxApi.getPromotionSnoozeUntil(),
+        inboxApi.listPromotionCandidates()
+      ]);
+      // snoozed_until > now → 빈 배열 (전체 스누즈).
+      if (snoozeUntil > Date.now()) {
+        set({ promotionCandidates: [] });
+        return;
+      }
+      const dismissedSet = new Set(dismissed);
+      const candidates: PromotionCandidate[] = raw
+        .filter((c) => !dismissedSet.has(c.tag))
+        .map((c) => ({ ...c, suggestedName: toTitleCase(c.tag) }));
+      set({ promotionCandidates: candidates });
+    } catch (e) {
+      console.error('[inbox] loadPromotionCandidates failed', e);
+      set({ promotionCandidates: [] });
+    }
+  },
+  async acceptPromotion(tag, customName, color) {
+    const candidate = get().promotionCandidates.find((c) => c.tag === tag);
+    if (!candidate) return;
+    const r = await notebookApi.create({ name: customName, color });
+    if (!r.ok) return;
+    const notebookId = r.notebook.id;
+    await Promise.all(candidate.noteIds.map((noteId) => notebookApi.moveNote(noteId, notebookId)));
+    // state: candidate 제거 + notebooks 갱신 + sidebar 열기 + 새 notebook 선택.
+    set({
+      promotionCandidates: get().promotionCandidates.filter((c) => c.tag !== tag),
+      notebooks: [...get().notebooks, r.notebook],
+      sidebarVisible: true,
+      selectedNotebookId: notebookId
+    });
+    await get().refreshMeta();
+  },
+  async snoozePromotion() {
+    const snoozeUntil = Date.now() + 24 * 60 * 60 * 1000;
+    await inboxApi.setPromotionSnoozeUntil(snoozeUntil);
+    set({ promotionCandidates: [] });
+  },
+  async dismissPromotion(tag) {
+    await inboxApi.addPromotionDismissedTag(tag);
+    set({ promotionCandidates: get().promotionCandidates.filter((c) => c.tag !== tag) });
+  },
+  // v0.4 T5 — AI batch classify actions.
+  async runBatchClassify() {
+    set({ batchClassifying: true });
+    try {
+      const r = await inboxApi.batchClassifyDefault();
+      set({ batchClassifyResult: r, batchClassifying: false });
+    } catch (e) {
+      console.error('[inbox] batchClassify failed', e);
+      set({ batchClassifying: false });
+    }
+  },
+  clearBatchClassify() {
+    set({ batchClassifyResult: null });
+  },
+  async acceptBatchAssignments(accepted) {
+    await Promise.all(accepted.map((a) => notebookApi.moveNote(a.noteId, a.notebookId)));
+    set({ batchClassifyResult: null });
+    await get().refreshMeta();
+    await get().loadByView(get().view as 'inbox' | 'completed' | 'trash');
   }
 }));

src/renderer/quickcapture/App.tsx

@@ -3,6 +3,9 @@ import { captureApi } from './api.js';
 
 interface PastedImage { url: string; buffer: ArrayBuffer; }
 
+// 저장 단축키 modifier — macOS 는 Cmd, 그 외는 Ctrl.
+const MOD_KEY = /Mac/i.test(navigator.platform) ? 'Cmd' : 'Ctrl';
+
 export function App(): React.ReactElement {
   const [text, setText] = useState('');
   const [images, setImages] = useState<PastedImage[]>([]);
@@ -65,7 +68,7 @@ export function App(): React.ReactElement {
           {images.map((i, idx) => (<img key={idx} src={i.url} alt="" />))}
         </div>
       )}
-      <div className="hint">Ctrl+Enter 저장 · Esc 취소 · 이미지 붙여넣기</div>
+      <div className="hint">{MOD_KEY}+Enter 저장 · Esc 취소 · 이미지 붙여넣기</div>
       {err && <div className="err">{err}</div>}
     </div>
   );

src/renderer/quickcapture/index.html

@@ -2,7 +2,7 @@
 <html lang="ko">
   <head>
     <meta charset="UTF-8" />
-    <meta http-equiv="Content-Security-Policy" content="default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'" />
+    <meta http-equiv="Content-Security-Policy" content="default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data: blob:" />
     <title>Inkling Capture</title>
     <style>
       html, body, #root { margin: 0; height: 100%; background: transparent; font-family: system-ui, sans-serif; overflow: hidden; }

src/shared/types.ts

@@ -13,8 +13,9 @@ export interface NoteMedia {
 
 export type AiStatus = 'pending' | 'done' | 'failed' | 'disabled';
 
-// v0.2.9 Cut B — 노트 status 4분기 (사용자 액션). m004 마이그레이션 + setStatus.
-export type NoteStatus = 'active' | 'completed' | 'archived' | 'trashed';
+// v0.2.9 Cut B — 노트 status 3분기 (사용자 액션). m004 마이그레이션 + setStatus.
+// v0.4 Task 16 — 'archived' 제거. m008 마이그레이션이 DB 의 archived 를 completed 로 통합.
+export type NoteStatus = 'active' | 'completed' | 'trashed';
 
 export interface NoteTag {
   name: string;
@@ -31,6 +32,40 @@ export interface NoteRevision {
   editedBy: 'user' | 'capture';
 }
 
+// v0.2.11 Cut D — 회고 view aggregate.
+export type ReviewPeriod = 'daily' | 'weekly' | 'monthly';
+export interface ReviewAggregate {
+  totalCount: number;
+  recentNotes: Note[];
+  tagCounts: Array<{ tag: string; count: number }>;
+  dueProgress: { total: number; passed: number; pending: number };
+}
+
+// v0.3.0 Cut E — 양방향 sync 결과 + conflict.
+// `path` = git index 의 conflict 파일 상대경로 (예: 'notes/2026-05-09-abc12345-회의.md').
+// F5 export 의 filename 은 date-id8-slug 패턴 — UUID 가 아니라 path 가 맞는 식별자.
+export interface SyncConflict {
+  path: string;
+  localText: string;
+  remoteText: string;
+}
+
+export interface SyncStatus {
+  ok: boolean;
+  reason?: string;
+  changed?: boolean;
+  localSha?: string | null;
+  pushed?: boolean;
+  importedCount?: number;
+  conflicts?: SyncConflict[];
+}
+
+export interface SyncStatusSnapshot {
+  lastAt: string | null;
+  lastResult: SyncStatus | null;
+  nextAt: string | null;
+}
+
 export interface Note {
   id: string;
   rawText: string;
@@ -58,6 +93,38 @@ export interface Note {
   updatedAt: string;
   tags: NoteTag[];
   media: NoteMedia[];
+  // v0.4 — m008 마이그레이션 보장 (notebook_id NOT NULL, default notebook 자동 할당).
+  notebookId: string;
+}
+
+// v0.4 T4 — AI batch classify 결과.
+export interface BatchClassifyAssignment {
+  noteId: string;
+  notebookId: string | null;
+  notebookName: string | null;
+}
+
+export interface BatchClassifyResult {
+  assignments: BatchClassifyAssignment[];
+  skippedReason?: string;
+}
+
+// v0.4 Task 11 — tag 기반 notebook 승격 제안 후보.
+// suggestedName 은 renderer 가 toTitleCase(tag) 로 채움 — IPC 응답에는 없음.
+export interface PromotionCandidate {
+  tag: string;
+  noteIds: string[];
+  suggestedName: string;
+}
+
+// v0.4 — Notebook: 노트 묶음 단위. noteCount = status='active' 노트 수.
+export interface Notebook {
+  id: string;
+  name: string;
+  color: string | null;
+  createdAt: string;
+  updatedAt: string;
+  noteCount: number;
 }
 
 export interface WeeklyContinuity {
@@ -79,6 +146,8 @@ export interface AutostartDiagnostic {
   withArgs: { openAtLogin: boolean; executableWillLaunchAtLogin: boolean };
   noArgs: { openAtLogin: boolean; executableWillLaunchAtLogin: boolean };
   execPath: string;
+  /** mismatch 판정 플랫폼 분기용 (macOS 의 SMAppService API 한계 우회). */
+  platform: NodeJS.Platform;
   registryPath?: string;
   registryValue?: string | null;
 }
@@ -89,7 +158,7 @@ export interface AutostartResponse {
 }
 
 export interface InboxApi {
-  listNotes(opts: { limit: number; cursor?: string }): Promise<Note[]>;
+  listNotes(opts: { limit: number; cursor?: string; notebookId?: string }): Promise<Note[]>;
   updateAiFields(
     noteId: string,
     fields: { title?: string; summary?: string; tags?: string[] }
@@ -115,11 +184,14 @@ export interface InboxApi {
   onOllamaStatus(cb: (status: { ok: boolean; reason?: string }) => void): () => void;
   retryAllFailed(): Promise<{ count: number }>;
   getFailedCount(): Promise<number>;
+  // v0.3.9 — per-note retry/cancel. failed/pending 노트의 사용자 unblock path.
+  retryOneFailed(id: string): Promise<{ ok: boolean }>;
+  cancelPending(id: string): Promise<{ ok: boolean }>;
   listRecallCandidate(): Promise<Note | null>;
   markRecallOpened(id: string): Promise<{ note: Note }>;
   dismissRecall(id: string): Promise<{ note: Note }>;
-  emitRecallShown(id: string): Promise<void>;
-  emitRecallSnoozed(id: string): Promise<void>;
+  emitRecallShown(id: string): void;
+  emitRecallSnoozed(id: string): 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 전환 요청 구독.
@@ -146,8 +218,9 @@ export interface InboxApi {
   // v0.2.8 Cut A — 첨부 이미지를 OS 기본 뷰어로 열기 (Task 3).
   openMedia(relPath: string): Promise<{ ok: true } | { ok: false; reason: string }>;
   // v0.2.9 Cut B Task 4 — status 별 노트 목록 + status 별 count.
-  listByStatus(status: NoteStatus, opts?: { limit?: number }): Promise<Note[]>;
-  countsByStatus(): Promise<{ active: number; completed: number; archived: number; trashed: number }>;
+  // v0.4 — notebookId 옵션 추가. archived 제거 (Task 16 — NoteStatus 에서 제거됨).
+  listByStatus(status: NoteStatus, opts?: { limit?: number; notebookId?: string }): Promise<Note[]>;
+  countsByStatus(opts?: { notebookId?: string }): Promise<{ active: number; completed: number; trashed: number }>;
   // v0.2.9 Cut B Task 8 — 4분기 status 전이 + AI 자동 분류 추천.
   setStatus(
     id: string,
@@ -160,8 +233,20 @@ export interface InboxApi {
     ollama?: { endpoint: string; model: string };
     ai_enabled?: boolean;
     onboarding_completed?: boolean;
+    sync_repo_url?: string | null;
+    sync_auto_enabled?: boolean;
+    sync_interval_min?: number;
+    // v0.3.1 Cut F
+    vision_model?: string | null;
+    vision_capable_cache?: string[];
+    vision_cache_at?: string;
+    // v0.4 — Sidebar UI state 영속화
+    sidebar_visible?: boolean;
+    sidebar_width?: number;
   }>;
   setAiEnabled(enabled: boolean): Promise<{ ok: true }>;
+  setSidebarVisible(visible: boolean): Promise<{ ok: true }>;
+  setSidebarWidth(width: number): Promise<{ ok: true }>;
   setOnboardingCompleted(completed: boolean): Promise<{ ok: true }>;
   // v0.2.9 Cut B Task 16 — ai_status='disabled' 메모 재투입 (사용자가 ai_enabled OFF→ON 전환 시).
   enqueueDisabled(): Promise<{ count: number }>;
@@ -170,11 +255,46 @@ export interface InboxApi {
   updateRawText(noteId: string, newText: string): Promise<{ ok: true } | { ok: false; reason: string }>;
   listRevisions(noteId: string): Promise<NoteRevision[]>;
   restoreRevision(noteId: string, revId: number): Promise<{ ok: true } | { ok: false; reason: string }>;
+  // v0.2.11 Cut D — FTS5 search + 회고 aggregate.
+  // v0.4 — notebookId 옵션 추가.
+  search(query: string, opts?: { limit?: number; status?: NoteStatus; notebookId?: string }): Promise<Note[]>;
+  reviewAggregate(period: ReviewPeriod): Promise<ReviewAggregate>;
+  // v0.3.0 Cut E — 양방향 sync.
+  configureSync(url: string | null): Promise<{ ok: true } | { ok: false; reason: string }>;
+  testSyncConnection(): Promise<{ ok: true } | { ok: false; reason: string }>;
+  listConflicts(): Promise<SyncConflict[]>;
+  resolveConflict(path: string, choice: 'local' | 'remote'): Promise<{ ok: true } | { ok: false; reason: string }>;
+  getSyncStatus(): Promise<SyncStatusSnapshot>;
+  setSyncAutoEnabled(enabled: boolean): Promise<{ ok: true }>;
+  setSyncIntervalMin(value: number): Promise<{ ok: true } | { ok: false; reason: string }>;
+  // v0.3.1 Cut F — vision capability detection + 모델 선택.
+  getVisionModels(): Promise<{ models: string[]; at: string | null; selected: string | null }>;
+  setVisionModel(value: string | null): Promise<{ ok: true }>;
+  refreshVisionCache(): Promise<{ ok: true; models: string[] } | { ok: false; reason: string }>;
+  // v0.4 T4 — AI batch classify: default notebook 노트 일괄 fit 매칭 (단일 prompt).
+  batchClassifyDefault(): Promise<BatchClassifyResult>;
+  // v0.4 Task 11 — promotion candidates + dismissed/snoozed 영속화.
+  listPromotionCandidates(): Promise<PromotionCandidate[]>;
+  getPromotionDismissedTags(): Promise<string[]>;
+  addPromotionDismissedTag(tag: string): Promise<void>;
+  getPromotionSnoozeUntil(): Promise<number>;
+  setPromotionSnoozeUntil(ms: number): Promise<void>;
+}
+
+export interface NotebookApi {
+  list(): Promise<Notebook[]>;
+  create(input: { name: string; color?: string }): Promise<{ ok: true; notebook: Notebook } | { ok: false; reason: string }>;
+  rename(id: string, name: string): Promise<{ ok: true } | { ok: false; reason: string }>;
+  setColor(id: string, color: string | null): Promise<{ ok: true }>;
+  delete(id: string): Promise<{ ok: true } | { ok: false; reason: 'has_notes' | 'not_found' }>;
+  moveNote(noteId: string, notebookId: string): Promise<{ ok: true }>;
+  reorder(id: string, direction: 'up' | 'down'): Promise<{ ok: boolean }>;
 }
 
 export interface InklingApi {
   capture: CaptureApi;
   inbox: InboxApi;
+  notebook: NotebookApi;
 }
 
 export {};

tests/unit/AiProviderSection.test.tsx

@@ -11,7 +11,11 @@ vi.mock('../../src/renderer/inbox/api.js', () => ({
     getSettings: vi.fn(async () => ({ ai_enabled: true })),
     setAiEnabled: vi.fn(async () => ({ ok: true })),
     getDisabledCount: vi.fn(async () => 0),
-    enqueueDisabled: vi.fn(async () => ({ count: 0 }))
+    enqueueDisabled: vi.fn(async () => ({ count: 0 })),
+    // v0.3.1 Cut F — VisionSection 이 AiProviderSection 에 마운트되어 호출.
+    getVisionModels: vi.fn(async () => ({ models: [], at: null, selected: null })),
+    setVisionModel: vi.fn(async () => ({ ok: true as const })),
+    refreshVisionCache: vi.fn(async () => ({ ok: true as const, models: [] }))
   }
 }));
 

tests/unit/AiWorker.test.ts

@@ -14,7 +14,7 @@ function makeProvider(overrides: Partial<InferenceProvider> = {}): InferenceProv
   return {
     name: 'mock',
     generate: vi.fn(async (): Promise<AiResponse> => ({
-      title: '제목', summary: 'a\nb\nc', tags: ['tag'], dueDate: null
+      title: '제목', summary: 'a\nb\nc', tags: ['tag'], dueDate: null, notebookMatch: null
     })),
     healthCheck: vi.fn(async () => ({ ok: true })),
     ...overrides
@@ -77,7 +77,7 @@ describe('AiWorker', () => {
         running++; max = Math.max(max, running);
         await new Promise((r) => setTimeout(r, 10));
         running--;
-        return { title: '제목', summary: 'a\nb\nc', tags: [], dueDate: null };
+        return { title: '제목', summary: 'a\nb\nc', tags: [], dueDate: null, notebookMatch: null };
       })
     });
     const w = new AiWorker(repo, new ProviderHolder(provider), { backoffsMs: [0, 0, 0] });
@@ -137,7 +137,8 @@ describe('AiWorker', () => {
         title: '아무 메모',
         summary: 'a\nb\nc',
         tags: [],
-        dueDate: null
+        dueDate: null,
+        notebookMatch: null
       }),
       healthCheck: async () => ({ ok: true })
     } as any;
@@ -159,7 +160,7 @@ describe('AiWorker', () => {
       generate: async (input: any) => {
         seen.todayKst = input.todayKst;
         seen.dueDateCandidates = input.dueDateCandidates;
-        return { title: '메모', summary: 'a\nb\nc', tags: [], dueDate: null };
+        return { title: '메모', summary: 'a\nb\nc', tags: [], dueDate: null, notebookMatch: null };
       },
       healthCheck: async () => ({ ok: true })
     } as any;
@@ -181,7 +182,7 @@ describe('AiWorker', () => {
       name: 'mock',
       generate: async (input: any) => {
         captured = input;
-        return { title: '내일', summary: 'a\nb\nc', tags: [], dueDate: null };
+        return { title: '내일', summary: 'a\nb\nc', tags: [], dueDate: null, notebookMatch: null };
       },
       healthCheck: async () => ({ ok: true })
     } as any;
@@ -409,7 +410,7 @@ describe('AiWorker — unreachable/timeout infinite retry (v0.2.3 #2)', () => {
       generate: vi.fn(async (): Promise<AiResponse> => {
         callCount += 1;
         if (callCount <= 2) throw new Error('ECONNREFUSED');
-        return { title: 't', summary: 's', tags: [], dueDate: null };
+        return { title: 't', summary: 's', tags: [], dueDate: null, notebookMatch: null };
       })
     });
     const w = new AiWorker(repo, new ProviderHolder(provider), {
@@ -442,16 +443,17 @@ describe('AiWorker — vocab fetch + per-tag hit/miss (v0.2.3 #3 T7)', () => {
 
     const { id } = repo.create({ rawText: 'x' });
     const generateMock = vi.fn(async () => ({
-      title: '제목', summary: 'a\nb\nc', tags: ['design'], dueDate: null
+      title: '제목', summary: 'a\nb\nc', tags: ['design'], dueDate: null, notebookMatch: null
     }));
     const w = new AiWorker(repo, new ProviderHolder(makeProvider({ generate: generateMock })), {
       backoffsMs: [0, 0, 0]
     });
     await w.enqueue(id);
     await w.drain();
-    expect(generateMock).toHaveBeenCalledWith(expect.objectContaining({
-      vocab: expect.arrayContaining(['design'])
-    }));
+    expect(generateMock).toHaveBeenCalledWith(
+      expect.objectContaining({ vocab: expect.arrayContaining(['design']) }),
+      expect.anything()
+    );
   });
 
   it('emits tag_vocab_hit for vocab tags + tag_vocab_miss for new tags', async () => {
@@ -464,7 +466,8 @@ describe('AiWorker — vocab fetch + per-tag hit/miss (v0.2.3 #3 T7)', () => {
       generate: vi.fn(async () => ({
         title: 't', summary: 'a\nb\nc',
         tags: ['design', 'newtag'],  // 1 hit + 1 miss
-        dueDate: null
+        dueDate: null,
+        notebookMatch: null
       }))
     });
     const emits: EmittedEvent[] = [];
@@ -494,7 +497,8 @@ describe('AiWorker — vocab fetch + per-tag hit/miss (v0.2.3 #3 T7)', () => {
       generate: vi.fn(async () => ({
         title: 't', summary: 'a\nb\nc',
         tags: ['design', 'meeting', 'qa'],
-        dueDate: null
+        dueDate: null,
+        notebookMatch: null
       }))
     });
     const emits: EmittedEvent[] = [];
@@ -519,7 +523,8 @@ describe('AiWorker — vocab fetch + per-tag hit/miss (v0.2.3 #3 T7)', () => {
       generate: vi.fn(async () => ({
         title: 't', summary: 'a\nb\nc',
         tags: ['design', 'meeting', 'qa'],
-        dueDate: null
+        dueDate: null,
+        notebookMatch: null
       }))
     });
     const emits: EmittedEvent[] = [];
@@ -543,7 +548,8 @@ describe('AiWorker — vocab fetch + per-tag hit/miss (v0.2.3 #3 T7)', () => {
       generate: vi.fn(async () => ({
         title: 't', summary: 'a\nb\nc',
         tags: ['design', 'design', 'meeting'],  // 중복 'design' 의도적
-        dueDate: null
+        dueDate: null,
+        notebookMatch: null
       }))
     });
     const emits: EmittedEvent[] = [];
@@ -559,3 +565,192 @@ describe('AiWorker — vocab fetch + per-tag hit/miss (v0.2.3 #3 T7)', () => {
     expect(miss).toHaveLength(1);  // 'meeting' 1 miss
   });
 });
+
+describe('AiWorker notebook matching', () => {
+  let db: Database.Database;
+  let repo: NoteRepository;
+
+  beforeEach(() => {
+    db = new Database(':memory:');
+    runMigrations(db);
+    repo = new NoteRepository(db);
+  });
+
+  it('AI 응답의 notebookMatch 가 valid 이름이면 moveNote 호출', async () => {
+    const moveNote = vi.fn();
+    const notebookRepo = {
+      list: () => [{ id: 'nb-회사', name: '회사', color: null, createdAt: 't', updatedAt: 't', noteCount: 0 }],
+      findByName: (n: string) => n === '회사' ? { id: 'nb-회사', name: '회사', color: null, createdAt: 't', updatedAt: 't', noteCount: 0 } : null,
+      moveNote
+    };
+    const provider = makeProvider({
+      generate: vi.fn(async (): Promise<AiResponse> => ({
+        title: '제목', summary: 'a\nb\nc', tags: [], dueDate: null, notebookMatch: '회사'
+      }))
+    });
+    const { id } = repo.create({ rawText: '회사 업무' });
+    const w = new AiWorker(repo, new ProviderHolder(provider), {
+      backoffsMs: [0],
+      notebookRepo
+    });
+    await w.enqueue(id);
+    await w.drain();
+    expect(moveNote).toHaveBeenCalledWith(id, 'nb-회사');
+  });
+
+  it('AI 응답 notebookMatch null 시 moveNote 호출 X', async () => {
+    const moveNote = vi.fn();
+    const notebookRepo = {
+      list: () => [{ id: 'nb-회사', name: '회사', color: null, createdAt: 't', updatedAt: 't', noteCount: 0 }],
+      findByName: (_n: string) => null,
+      moveNote
+    };
+    const provider = makeProvider({
+      generate: vi.fn(async (): Promise<AiResponse> => ({
+        title: '제목', summary: 'a\nb\nc', tags: [], dueDate: null, notebookMatch: null
+      }))
+    });
+    const { id } = repo.create({ rawText: '일반 메모' });
+    const w = new AiWorker(repo, new ProviderHolder(provider), {
+      backoffsMs: [0],
+      notebookRepo
+    });
+    await w.enqueue(id);
+    await w.drain();
+    expect(moveNote).not.toHaveBeenCalled();
+  });
+
+  it('notebooks 배열을 provider.generate 에 전달', async () => {
+    let capturedNotebooks: string[] | undefined;
+    const notebookRepo = {
+      list: () => [
+        { id: 'nb-1', name: '회사', color: null, createdAt: 't', updatedAt: 't', noteCount: 0 },
+        { id: 'nb-2', name: '개인', color: null, createdAt: 't', updatedAt: 't', noteCount: 0 }
+      ],
+      findByName: (_n: string) => null,
+      moveNote: vi.fn()
+    };
+    const provider = makeProvider({
+      generate: vi.fn(async (input: any): Promise<AiResponse> => {
+        capturedNotebooks = input.notebooks;
+        return { title: '제목', summary: 'a\nb\nc', tags: [], dueDate: null, notebookMatch: null };
+      })
+    });
+    const { id } = repo.create({ rawText: '테스트' });
+    const w = new AiWorker(repo, new ProviderHolder(provider), {
+      backoffsMs: [0],
+      notebookRepo
+    });
+    await w.enqueue(id);
+    await w.drain();
+    expect(capturedNotebooks).toEqual(['회사', '개인']);
+  });
+
+  it('notebookRepo 미전달 시 notebooks 빈 배열 전달 + moveNote 호출 X', async () => {
+    let capturedNotebooks: string[] | undefined;
+    const provider = makeProvider({
+      generate: vi.fn(async (input: any): Promise<AiResponse> => {
+        capturedNotebooks = input.notebooks;
+        return { title: '제목', summary: 'a\nb\nc', tags: [], dueDate: null, notebookMatch: '회사' };
+      })
+    });
+    const { id } = repo.create({ rawText: '테스트' });
+    const w = new AiWorker(repo, new ProviderHolder(provider), { backoffsMs: [0] });
+    await w.enqueue(id);
+    await w.drain();
+    expect(capturedNotebooks).toEqual([]);
+    // notebookRepo 없으므로 moveNote 미호출 — note 는 done 상태
+    expect(repo.findById(id)?.aiStatus).toBe('done');
+  });
+});
+
+describe('vocab COLLATE NOCASE', () => {
+  let db: Database.Database;
+  let repo: NoteRepository;
+
+  beforeEach(() => {
+    db = new Database(':memory:');
+    runMigrations(db);
+    repo = new NoteRepository(db);
+  });
+
+  it('hits when vocab has lowercase and AI returns capital', async () => {
+    // Pre-seed: 'design' in vocab (lowercase)
+    const seed = repo.create({ rawText: 'seed' }).id;
+    repo.updateAiResult(seed, { title: 't', summary: 'a\nb\nc', tags: ['design'], provider: 'p' });
+
+    const { id } = repo.create({ rawText: 'x' });
+    const provider = makeProvider({
+      generate: vi.fn(async () => ({
+        title: 't', summary: 'a\nb\nc',
+        tags: ['Design'],  // AI returns capitalized — DB COLLATE NOCASE matches 'design'
+        dueDate: null,
+        notebookMatch: null
+      }))
+    });
+    const emits: EmittedEvent[] = [];
+    const w = new AiWorker(repo, new ProviderHolder(provider), {
+      backoffsMs: [0, 0, 0],
+      telemetry: { emit: vi.fn(async (input) => { emits.push(input); }) }
+    });
+    await w.enqueue(id);
+    await w.drain();
+    expect(emits.filter((e) => e.kind === 'tag_vocab_hit')).toHaveLength(1);
+    expect(emits.filter((e) => e.kind === 'tag_vocab_miss')).toHaveLength(0);
+  });
+
+  it('hits when vocab has capital and AI returns lowercase', async () => {
+    // Scenario: vocab contains 'Design' (capital), AI returns 'design' (lowercase).
+    // getTopUsedTags filters via KEBAB_CASE_RE (/^[a-z0-9-]+$/) so 'Design' would be
+    // stripped in production. We stub getTopUsedTags to inject the capital vocab directly,
+    // and pre-seed the DB so getTagIdByName (COLLATE NOCASE) can resolve 'design' → tagId.
+    const seed = repo.create({ rawText: 'seed' }).id;
+    repo.updateAiResult(seed, { title: 't', summary: 'a\nb\nc', tags: ['Design'], provider: 'p' });
+    // Inject capital vocab bypassing the kebab filter
+    vi.spyOn(repo, 'getTopUsedTags').mockReturnValueOnce(['Design']);
+
+    const { id } = repo.create({ rawText: 'x' });
+    const provider = makeProvider({
+      generate: vi.fn(async () => ({
+        title: 't', summary: 'a\nb\nc',
+        tags: ['design'],  // AI returns lowercase — DB COLLATE NOCASE matches 'Design'
+        dueDate: null,
+        notebookMatch: null
+      }))
+    });
+    const emits: EmittedEvent[] = [];
+    const w = new AiWorker(repo, new ProviderHolder(provider), {
+      backoffsMs: [0, 0, 0],
+      telemetry: { emit: vi.fn(async (input) => { emits.push(input); }) }
+    });
+    await w.enqueue(id);
+    await w.drain();
+    expect(emits.filter((e) => e.kind === 'tag_vocab_hit')).toHaveLength(1);
+    expect(emits.filter((e) => e.kind === 'tag_vocab_miss')).toHaveLength(0);
+  });
+
+  it('still hits when both vocab and AI tag are same lowercase (regression)', async () => {
+    // Pre-seed: 'design' in vocab (lowercase)
+    const seed = repo.create({ rawText: 'seed' }).id;
+    repo.updateAiResult(seed, { title: 't', summary: 'a\nb\nc', tags: ['design'], provider: 'p' });
+
+    const { id } = repo.create({ rawText: 'x' });
+    const provider = makeProvider({
+      generate: vi.fn(async () => ({
+        title: 't', summary: 'a\nb\nc',
+        tags: ['design'],  // same lowercase — should still hit
+        dueDate: null,
+        notebookMatch: null
+      }))
+    });
+    const emits: EmittedEvent[] = [];
+    const w = new AiWorker(repo, new ProviderHolder(provider), {
+      backoffsMs: [0, 0, 0],
+      telemetry: { emit: vi.fn(async (input) => { emits.push(input); }) }
+    });
+    await w.enqueue(id);
+    await w.drain();
+    expect(emits.filter((e) => e.kind === 'tag_vocab_hit')).toHaveLength(1);
+    expect(emits.filter((e) => e.kind === 'tag_vocab_miss')).toHaveLength(0);
+  });
+});

tests/unit/AiWorker.vision.test.ts

@@ -0,0 +1,172 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { writeFile, mkdtemp, mkdir, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import Database from 'better-sqlite3';
+import { runMigrations } from '@main/db/migrations/index.js';
+import { NoteRepository } from '@main/repository/NoteRepository.js';
+import { AiWorker } from '@main/ai/AiWorker.js';
+import { ProviderHolder } from '@main/ai/ProviderHolder.js';
+import { MediaStore } from '@main/services/MediaStore.js';
+import type { AiResponse } from '@main/ai/schema.js';
+import type { InferenceProvider } from '@main/ai/InferenceProvider.js';
+
+describe('AiWorker — vision path (v0.3.1 Cut F)', () => {
+  let db: Database.Database;
+  let repo: NoteRepository;
+  let workDir: string;
+  let mediaStore: MediaStore;
+
+  beforeEach(async () => {
+    db = new Database(':memory:');
+    db.pragma('foreign_keys = ON');
+    runMigrations(db);
+    repo = new NoteRepository(db);
+    workDir = await mkdtemp(join(tmpdir(), 'inkling-vision-'));
+    mediaStore = new MediaStore(workDir);
+  });
+
+  afterEach(async () => {
+    db.close();
+    await rm(workDir, { recursive: true, force: true });
+  });
+
+  function makeWorker(
+    generate: (input: Parameters<InferenceProvider['generate']>[0], opts?: Parameters<InferenceProvider['generate']>[1]) => Promise<AiResponse>,
+    getVisionModel: () => Promise<string | null>
+  ): AiWorker {
+    const provider: InferenceProvider = {
+      name: 'fake',
+      generate,
+      abort: () => {},
+      healthCheck: vi.fn(async () => ({ ok: true }))
+    };
+    const holder = new ProviderHolder(provider);
+    const settings = { getVisionModel };
+    const logger = { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+    return new AiWorker(repo, holder, {
+      backoffsMs: [0, 0, 0],
+      logger,
+      settings,
+      mediaStore,
+      now: () => new Date('2026-05-10T05:00:00Z')
+    });
+  }
+
+  it('visionModel + media 있음 → provider.generate 가 images + opts 받음', async () => {
+    const { id } = repo.create({ rawText: '이미지 메모' });
+    await mkdir(join(workDir, 'media', id), { recursive: true });
+    await writeFile(join(workDir, 'media', id, '1.png'), Buffer.from([0x89, 0x50, 0x4e, 0x47]));
+    repo.insertMedia([{ noteId: id, kind: 'image', relPath: `media/${id}/1.png`, mime: 'image/png', bytes: 4 }]);
+
+    const calls: Array<Parameters<InferenceProvider['generate']>> = [];
+    const generate = vi.fn(async (
+      input: Parameters<InferenceProvider['generate']>[0],
+      opts?: Parameters<InferenceProvider['generate']>[1]
+    ): Promise<AiResponse> => {
+      calls.push([input, opts]);
+      return { title: 't', summary: 'a\nb\nc', tags: [], dueDate: null, notebookMatch: null };
+    });
+    const getVisionModel = vi.fn(async (): Promise<string | null> => 'gemma3:12b-vision');
+    const worker = makeWorker(generate, getVisionModel);
+    await worker.enqueue(id);
+    await worker.drain();
+
+    expect(calls.length).toBeGreaterThan(0);
+    const [callInput, callOpts] = calls[0]!;
+    expect(callInput.images).toHaveLength(1);
+    expect(callInput.images![0]!.mime).toBe('image/png');
+    expect(callOpts?.visionModel).toBe('gemma3:12b-vision');
+  });
+
+  it('visionModel null이면 text-only (images undefined)', async () => {
+    const { id } = repo.create({ rawText: 'just text' });
+    const calls: Array<Parameters<InferenceProvider['generate']>> = [];
+    const generate = vi.fn(async (
+      input: Parameters<InferenceProvider['generate']>[0],
+      opts?: Parameters<InferenceProvider['generate']>[1]
+    ): Promise<AiResponse> => {
+      calls.push([input, opts]);
+      return { title: 't', summary: 'a\nb\nc', tags: [], dueDate: null, notebookMatch: null };
+    });
+    const getVisionModel = vi.fn(async (): Promise<string | null> => null);
+    const worker = makeWorker(generate, getVisionModel);
+    await worker.enqueue(id);
+    await worker.drain();
+
+    expect(calls.length).toBeGreaterThan(0);
+    expect(calls[0]![0].images).toBeUndefined();
+  });
+
+  it('v0.3.14 — 본문 빈 + 이미지만 첨부 → generate 호출 skip + 자동 placeholder', async () => {
+    const { id } = repo.create({ rawText: '' }); // 빈 본문
+    await mkdir(join(workDir, 'media', id), { recursive: true });
+    await writeFile(join(workDir, 'media', id, '1.png'), Buffer.from([0x89, 0x50, 0x4e, 0x47]));
+    repo.insertMedia([{ noteId: id, kind: 'image', relPath: `media/${id}/1.png`, mime: 'image/png', bytes: 4 }]);
+
+    const calls: Array<Parameters<InferenceProvider['generate']>> = [];
+    const generate = vi.fn(async (
+      input: Parameters<InferenceProvider['generate']>[0],
+      opts?: Parameters<InferenceProvider['generate']>[1]
+    ): Promise<AiResponse> => {
+      calls.push([input, opts]);
+      return { title: 't', summary: 'a\nb\nc', tags: [], dueDate: null, notebookMatch: null };
+    });
+    const getVisionModel = vi.fn(async (): Promise<string | null> => 'gemma4:26b');
+    const worker = makeWorker(generate, getVisionModel);
+    await worker.enqueue(id);
+    await worker.drain();
+
+    // vision 호출 자체 skip
+    expect(calls.length).toBe(0);
+    // 노트가 자동 placeholder 로 done
+    const note = repo.findById(id);
+    expect(note?.aiStatus).toBe('done');
+    expect(note?.aiTitle).toContain('첨부 이미지');
+    expect(note?.aiSummary).toContain('이미지');
+    expect(note?.aiProvider).toBe('image-only-skip');
+  });
+
+  it('v0.3.14 — 이미지 다수 첨부 시 placeholder 가 개수 포함', async () => {
+    const { id } = repo.create({ rawText: '' });
+    await mkdir(join(workDir, 'media', id), { recursive: true });
+    await writeFile(join(workDir, 'media', id, '1.png'), Buffer.from([0x89]));
+    await writeFile(join(workDir, 'media', id, '2.png'), Buffer.from([0x89]));
+    repo.insertMedia([
+      { noteId: id, kind: 'image', relPath: `media/${id}/1.png`, mime: 'image/png', bytes: 1 },
+      { noteId: id, kind: 'image', relPath: `media/${id}/2.png`, mime: 'image/png', bytes: 1 }
+    ]);
+    const generate = vi.fn(async (): Promise<AiResponse> => ({ title: 't', summary: 'a\nb\nc', tags: [], dueDate: null, notebookMatch: null }));
+    const getVisionModel = vi.fn(async (): Promise<string | null> => 'gemma4:26b');
+    const worker = makeWorker(generate, getVisionModel);
+    await worker.enqueue(id);
+    await worker.drain();
+    const note = repo.findById(id);
+    expect(note?.aiTitle).toContain('2장');
+  });
+
+  it('5MB 초과 이미지 → throw → AiWorker 의 fail 분기 (generate 미호출)', async () => {
+    const { id } = repo.create({ rawText: 'big image' });
+    await mkdir(join(workDir, 'media', id), { recursive: true });
+    await writeFile(join(workDir, 'media', id, '1.png'), Buffer.alloc(6 * 1024 * 1024));
+    repo.insertMedia([{ noteId: id, kind: 'image', relPath: `media/${id}/1.png`, mime: 'image/png', bytes: 6 * 1024 * 1024 }]);
+
+    const calls: Array<Parameters<InferenceProvider['generate']>> = [];
+    const generate = vi.fn(async (
+      input: Parameters<InferenceProvider['generate']>[0],
+      opts?: Parameters<InferenceProvider['generate']>[1]
+    ): Promise<AiResponse> => {
+      calls.push([input, opts]);
+      return { title: 't', summary: 'a\nb\nc', tags: [], dueDate: null, notebookMatch: null };
+    });
+    const getVisionModel = vi.fn(async (): Promise<string | null> => 'gemma3:12b-vision');
+    const worker = makeWorker(generate, getVisionModel);
+    await worker.enqueue(id);
+    await worker.drain();
+
+    expect(calls.length).toBe(0);
+    // AiWorker catch 분기가 처리 — note 는 여전히 DB 에 존재
+    const note = repo.findById(id);
+    expect(note).toBeTruthy();
+  });
+});

tests/unit/App.test.tsx

@@ -4,10 +4,13 @@ import '@testing-library/jest-dom/vitest';
 import { render, screen, fireEvent, cleanup, waitFor } from '@testing-library/react';
 
 vi.mock('../../src/renderer/inbox/api.js', () => ({
+  notebookApi: {
+    list: vi.fn(async () => [])
+  },
   inboxApi: {
     listNotes: vi.fn(async () => []),
     listByStatus: vi.fn(async () => []),
-    countsByStatus: vi.fn(async () => ({ active: 0, completed: 0, archived: 0, trashed: 0 })),
+    countsByStatus: vi.fn(async () => ({ active: 0, completed: 0, trashed: 0 })),
     getContinuity: vi.fn(async () => ({
       weekStart: '', weekCount: 0, weekTarget: 7,
       consecutiveCompleteWeeks: 0, showRecoveryToast: false, lastNoteAt: null
@@ -53,10 +56,26 @@ vi.mock('../../src/renderer/inbox/api.js', () => ({
     // v0.2.9 Cut B Task 12 — onboarding wizard 분기. default 는 onboarding_completed=true 라 wizard 미표시.
     getSettings: vi.fn(async () => ({ onboarding_completed: true })),
     setAiEnabled: vi.fn(async () => ({ ok: true as const })),
+    setSidebarVisible: vi.fn(async () => ({ ok: true as const })),
+    setSidebarWidth: vi.fn(async () => ({ ok: true as const })),
     setOnboardingCompleted: vi.fn(async () => ({ ok: true as const })),
     // v0.2.9 Cut B Task 16 — AiProviderSection 가 SettingsPage 렌더 시 호출.
     getDisabledCount: vi.fn(async () => 0),
-    enqueueDisabled: vi.fn(async () => ({ count: 0 }))
+    enqueueDisabled: vi.fn(async () => ({ count: 0 })),
+    // v0.3.0 Cut E — SyncSection 이 SettingsPage 에 마운트되어 호출.
+    getSyncStatus: vi.fn(async () => ({ lastAt: null, lastResult: null, nextAt: null })),
+    setSyncAutoEnabled: vi.fn(async () => ({ ok: true as const })),
+    setSyncIntervalMin: vi.fn(async () => ({ ok: true as const })),
+    configureSync: vi.fn(async () => ({ ok: true as const })),
+    testSyncConnection: vi.fn(async () => ({ ok: true as const })),
+    // v0.3.1 Cut F — VisionSection 이 AiProviderSection 에 마운트되어 호출.
+    getVisionModels: vi.fn(async () => ({ models: [], at: null, selected: null })),
+    setVisionModel: vi.fn(async () => ({ ok: true as const })),
+    refreshVisionCache: vi.fn(async () => ({ ok: true as const, models: [] })),
+    // v0.4 Task 15 — loadPromotionCandidates 초기화 stub.
+    listPromotionCandidates: vi.fn(async () => []),
+    getPromotionDismissedTags: vi.fn(async () => []),
+    getPromotionSnoozeUntil: vi.fn(async () => 0)
   }
 }));
 
@@ -69,9 +88,10 @@ describe('App — settings view', () => {
     cleanup();
     useInbox.setState({
       view: 'inbox',
-      counts: { active: 0, completed: 0, archived: 0, trashed: 0 },
+      counts: { active: 0, completed: 0, trashed: 0 },
       showSettings: false, showTrash: false,
-      notes: [], trashNotes: [], trashCount: 0
+      notes: [], trashNotes: [], trashCount: 0,
+      sidebarVisible: false, notebooks: [], promotionCandidates: []
     });
   });
 
@@ -104,41 +124,66 @@ describe('App — settings view', () => {
   });
 });
 
-describe('App header — 4 tabs', () => {
+describe('App header — 3 tabs (v0.4)', () => {
   beforeEach(() => {
     cleanup();
     useInbox.setState({
       view: 'inbox',
-      counts: { active: 5, completed: 3, archived: 2, trashed: 1 },
+      counts: { active: 5, completed: 3, trashed: 1 },
       notes: [], trashNotes: [], trashCount: 0,
-      showTrash: false, showSettings: false
+      showTrash: false, showSettings: false,
+      sidebarVisible: false, notebooks: [], promotionCandidates: []
     });
     // loadInitial 이 비동기로 counts 를 덮어씀 — onboarding wizard async gate (Task 12) 도입
     // 후 render 가 await 후 발생하므로 mock 의 countsByStatus 가 테스트 기대값을 반환하도록 갱신.
-    vi.mocked(inboxApi.countsByStatus).mockResolvedValue({ active: 5, completed: 3, archived: 2, trashed: 1 });
+    // v0.4 Task 16 — countsByStatus 응답에서 archived 제거 (NoteStatus 에서 삭제됨).
+    vi.mocked(inboxApi.countsByStatus).mockResolvedValue({ active: 5, completed: 3, trashed: 1 });
   });
 
-  it('renders 4 tabs with counts', async () => {
+  it('renders 3 tabs (Inbox/완료/휴지통) with counts', async () => {
     render(<App />);
-    expect(await screen.findByRole('button', { name: /Inbox\(5\)/ })).toBeInTheDocument();
-    expect(screen.getByRole('button', { name: /완료\(3\)/ })).toBeInTheDocument();
-    expect(screen.getByRole('button', { name: /보관\(2\)/ })).toBeInTheDocument();
-    expect(screen.getByRole('button', { name: /휴지통\(1\)/ })).toBeInTheDocument();
+    expect(await screen.findByRole('tab', { name: /Inbox\(5\)/ })).toBeInTheDocument();
+    expect(screen.getByRole('tab', { name: /완료\(3\)/ })).toBeInTheDocument();
+    expect(screen.getByRole('tab', { name: /휴지통\(1\)/ })).toBeInTheDocument();
+  });
+
+  it('보관 탭이 헤더에 없음', async () => {
+    render(<App />);
+    await screen.findByRole('tab', { name: /Inbox/ });
+    expect(screen.queryByRole('tab', { name: /보관/ })).toBeNull();
   });
 
   it('clicking 완료 tab sets view=completed', async () => {
     render(<App />);
-    fireEvent.click(await screen.findByRole('button', { name: /완료/ }));
+    fireEvent.click(await screen.findByRole('tab', { name: /완료/ }));
     expect(useInbox.getState().view).toBe('completed');
   });
 
-  it('aria-pressed reflects current view', async () => {
-    useInbox.setState({ view: 'archived' });
+  it('inbox tab has aria-selected="true" when active', async () => {
     render(<App />);
-    const archivedBtn = await screen.findByRole('button', { name: /보관/ });
-    expect(archivedBtn.getAttribute('aria-pressed')).toBe('true');
-    const inboxBtn = screen.getByRole('button', { name: /Inbox/ });
-    expect(inboxBtn.getAttribute('aria-pressed')).toBe('false');
+    const inboxTab = await screen.findByRole('tab', { name: /Inbox/ });
+    expect(inboxTab).toHaveAttribute('aria-selected', 'true');
+  });
+
+  it('Cmd+B 키 이벤트가 toggleSidebar 호출', async () => {
+    // loadInitial 의 getSettings hydrate 후 state 가 정해진 시점 기준으로 토글 검증.
+    vi.mocked(inboxApi.getSettings).mockResolvedValue({ onboarding_completed: true, sidebar_visible: false });
+    render(<App />);
+    await screen.findByRole('tab', { name: /Inbox/ });
+    const initialVisible = useInbox.getState().sidebarVisible;
+    // jsdom 에서 navigator.platform = '' → isMac=false → ctrlKey 로 판단.
+    window.dispatchEvent(new KeyboardEvent('keydown', { key: 'b', ctrlKey: true, bubbles: true }));
+    // toggleSidebar 가 호출되면 sidebarVisible 이 반전됨.
+    expect(useInbox.getState().sidebarVisible).toBe(!initialVisible);
+  });
+
+  it('Sidebar 컴포넌트가 렌더 트리에 포함됨 (sidebarVisible=true)', async () => {
+    // loadInitial 의 getSettings 가 sidebar_visible=true 반환 (Strict Mode 중복 호출 대비 mockResolvedValue).
+    vi.mocked(inboxApi.getSettings).mockResolvedValue({ onboarding_completed: true, sidebar_visible: true });
+    render(<App />);
+    await screen.findByRole('tab', { name: /Inbox/ });
+    // loadInitial 비동기 hydrate 가 완료될 때까지 기다림
+    await waitFor(() => expect(document.querySelector('aside')).not.toBeNull());
   });
 });
 
@@ -147,9 +192,10 @@ describe('App — onboarding wizard', () => {
     cleanup();
     useInbox.setState({
       view: 'inbox',
-      counts: { active: 0, completed: 0, archived: 0, trashed: 0 },
+      counts: { active: 0, completed: 0, trashed: 0 },
       showSettings: false, showTrash: false,
-      notes: [], trashNotes: [], trashCount: 0
+      notes: [], trashNotes: [], trashCount: 0,
+      sidebarVisible: false, notebooks: [], promotionCandidates: []
     });
     // 각 테스트가 getSettings 의 default mock 을 직접 override.
     vi.mocked(inboxApi.getSettings).mockResolvedValue({ onboarding_completed: true });
@@ -165,7 +211,7 @@ describe('App — onboarding wizard', () => {
   it('does not render OnboardingWizard when onboarding_completed=true', async () => {
     vi.mocked(inboxApi.getSettings).mockResolvedValue({ onboarding_completed: true });
     render(<App />);
-    await screen.findByRole('button', { name: /Inbox/ });
+    await screen.findByRole('tab', { name: /Inbox/ });
     expect(screen.queryByText(/Inkling 사용 시작/)).toBeNull();
   });
 });

tests/unit/AutostartDiagnostic.test.ts

@@ -42,6 +42,7 @@ describe('AutostartDiagnostic — collectAutostartState', () => {
     expect(state.withArgs).toEqual({ openAtLogin: true, executableWillLaunchAtLogin: true });
     expect(state.noArgs).toEqual({ openAtLogin: false, executableWillLaunchAtLogin: true });
     expect(state.execPath).toBe(process.execPath);
+    expect(state.platform).toBe('darwin');
   });
 
   it('passes args=["--hidden"] for the first call, no args for the second', async () => {

tests/unit/AutostartSection.test.tsx

@@ -3,15 +3,17 @@ 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): {
+function makeDiag(open: boolean, platform: NodeJS.Platform = 'win32'): {
   withArgs: { openAtLogin: boolean; executableWillLaunchAtLogin: boolean };
   noArgs: { openAtLogin: boolean; executableWillLaunchAtLogin: boolean };
   execPath: string;
+  platform: NodeJS.Platform;
 } {
   return {
     withArgs: { openAtLogin: open, executableWillLaunchAtLogin: open },
     noArgs: { openAtLogin: open, executableWillLaunchAtLogin: open },
-    execPath: '/path/to/exe'
+    execPath: '/path/to/exe',
+    platform
   };
 }
 
@@ -51,7 +53,8 @@ describe('AutostartSection', () => {
       diagnostic: {
         withArgs: { openAtLogin: true, executableWillLaunchAtLogin: true },
         noArgs: { openAtLogin: false, executableWillLaunchAtLogin: true },
-        execPath: '/path/to/Inkling.exe'
+        execPath: '/path/to/Inkling.exe',
+        platform: 'win32'
       }
     });
     render(<AutostartSection />);
@@ -71,6 +74,7 @@ describe('AutostartSection', () => {
         withArgs: { openAtLogin: true, executableWillLaunchAtLogin: true },
         noArgs: { openAtLogin: true, executableWillLaunchAtLogin: true },
         execPath: 'C:\\app.exe',
+        platform: 'win32',
         registryPath: 'HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run\\Inkling',
         registryValue: '"C:\\app.exe" --hidden'
       }
@@ -89,7 +93,8 @@ describe('AutostartSection', () => {
       diagnostic: {
         withArgs: { openAtLogin: true, executableWillLaunchAtLogin: true },
         noArgs: { openAtLogin: true, executableWillLaunchAtLogin: true },
-        execPath: '/p'
+        execPath: '/p',
+        platform: 'win32'
       }
     });
     render(<AutostartSection />);
@@ -97,6 +102,38 @@ describe('AutostartSection', () => {
     expect(screen.queryByText(/⚠️/)).not.toBeInTheDocument();
   });
 
+  it('macOS: no false-positive mismatch when willLaunch=false (SMAppService 한계)', async () => {
+    const { inboxApi } = await import('../../src/renderer/inbox/api.js');
+    vi.mocked(inboxApi.getAutostart).mockResolvedValueOnce({
+      openAtLogin: true,
+      diagnostic: {
+        withArgs: { openAtLogin: true, executableWillLaunchAtLogin: false },
+        noArgs: { openAtLogin: true, executableWillLaunchAtLogin: false },
+        execPath: '/Applications/Inkling.app',
+        platform: 'darwin'
+      }
+    });
+    render(<AutostartSection />);
+    await screen.findByRole('checkbox');
+    expect(screen.queryByText(/⚠️/)).not.toBeInTheDocument();
+  });
+
+  it('Win: mismatch warning when openAtLogin=true but willLaunch=false', async () => {
+    const { inboxApi } = await import('../../src/renderer/inbox/api.js');
+    vi.mocked(inboxApi.getAutostart).mockResolvedValueOnce({
+      openAtLogin: true,
+      diagnostic: {
+        withArgs: { openAtLogin: true, executableWillLaunchAtLogin: false },
+        noArgs: { openAtLogin: true, executableWillLaunchAtLogin: false },
+        execPath: 'C:\\app.exe',
+        platform: 'win32'
+      }
+    });
+    render(<AutostartSection />);
+    await screen.findByRole('checkbox');
+    expect(await screen.findByText(/⚠️/)).toBeInTheDocument();
+  });
+
   it('"재등록" button calls setAutostart with current openAtLogin value', async () => {
     const { inboxApi } = await import('../../src/renderer/inbox/api.js');
     vi.mocked(inboxApi.getAutostart).mockResolvedValueOnce({
@@ -104,7 +141,8 @@ describe('AutostartSection', () => {
       diagnostic: {
         withArgs: { openAtLogin: true, executableWillLaunchAtLogin: true },
         noArgs: { openAtLogin: true, executableWillLaunchAtLogin: true },
-        execPath: '/p'
+        execPath: '/p',
+        platform: 'win32'
       }
     });
     render(<AutostartSection />);

tests/unit/BatchMoveModal.test.tsx

@@ -0,0 +1,143 @@
+// @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';
+import React from 'react';
+
+const { mockMoveNote, mockBatchClassifyDefault } = vi.hoisted(() => ({
+  mockMoveNote: vi.fn(async () => ({ ok: true as const })),
+  mockBatchClassifyDefault: vi.fn(async () => ({ assignments: [] }))
+}));
+
+vi.mock('../../src/renderer/inbox/api.js', () => ({
+  inboxApi: {
+    batchClassifyDefault: mockBatchClassifyDefault,
+    getContinuity: vi.fn(async () => ({ weekStart: '', weekCount: 0, weekTarget: 7, consecutiveCompleteWeeks: 0, showRecoveryToast: false, lastNoteAt: null })),
+    countsByStatus: vi.fn(async () => ({ active: 0, completed: 0, trashed: 0 })),
+    getSettings: vi.fn(async () => ({ ai_enabled: true })),
+    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),
+    listByStatus: vi.fn(async () => [])
+  },
+  notebookApi: {
+    moveNote: mockMoveNote,
+    list: vi.fn(async () => [])
+  }
+}));
+
+import { BatchMoveModal } from '../../src/renderer/inbox/components/BatchMoveModal';
+import { useInbox } from '../../src/renderer/inbox/store';
+
+const baseNote = {
+  id: 'n1',
+  rawText: '테스트 노트 내용',
+  aiTitle: 'AI 제목',
+  aiSummary: null,
+  aiStatus: 'done' as const,
+  aiError: null,
+  aiProvider: null,
+  aiGeneratedAt: null,
+  titleEditedByUser: false,
+  summaryEditedByUser: false,
+  userIntent: null,
+  intentPromptedAt: null,
+  dueDate: null,
+  dueDateEditedByUser: false,
+  deletedAt: null,
+  lastRecalledAt: null,
+  recallDismissedAt: null,
+  status: 'active' as const,
+  statusChangedAt: null,
+  moveReason: null,
+  createdAt: '2026-01-01T00:00:00Z',
+  updatedAt: '2026-01-01T00:00:00Z',
+  tags: [],
+  media: [],
+  notebookId: 'nb-default'
+};
+
+describe('BatchMoveModal', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    cleanup();
+    useInbox.setState({
+      batchClassifyResult: null,
+      batchClassifying: false,
+      notes: [],
+      notebooks: []
+    } as Partial<ReturnType<typeof useInbox.getState>>);
+  });
+
+  it('batchClassifyResult null 시 null 반환', () => {
+    useInbox.setState({ batchClassifyResult: null } as Partial<ReturnType<typeof useInbox.getState>>);
+    const { container } = render(<BatchMoveModal />);
+    expect(container).toBeEmptyDOMElement();
+  });
+
+  it('actionable 0건 시 "찾지 못했어요" 메시지 표시', () => {
+    useInbox.setState({
+      batchClassifyResult: { assignments: [{ noteId: 'n1', notebookId: null, notebookName: null }] }
+    } as Partial<ReturnType<typeof useInbox.getState>>);
+    render(<BatchMoveModal />);
+    expect(screen.getByText(/찾지 못했어요/)).toBeInTheDocument();
+  });
+
+  it('actionable 노트 표시 + checkbox 기본 체크', () => {
+    useInbox.setState({
+      batchClassifyResult: {
+        assignments: [
+          { noteId: 'n1', notebookId: 'nb1', notebookName: '업무' }
+        ]
+      },
+      notes: [{ ...baseNote, id: 'n1', aiTitle: 'AI 제목' }]
+    } as Partial<ReturnType<typeof useInbox.getState>>);
+    render(<BatchMoveModal />);
+    expect(screen.getByText('AI 제목')).toBeInTheDocument();
+    expect(screen.getByText(/→ 업무/)).toBeInTheDocument();
+    const checkbox = screen.getByRole('checkbox') as HTMLInputElement;
+    expect(checkbox.checked).toBe(true);
+  });
+
+  it('checkbox toggle 시 selectedIds 변경 (체크 해제 후 확인 버튼 비활성)', () => {
+    useInbox.setState({
+      batchClassifyResult: {
+        assignments: [
+          { noteId: 'n1', notebookId: 'nb1', notebookName: '업무' }
+        ]
+      },
+      notes: [{ ...baseNote, id: 'n1' }]
+    } as Partial<ReturnType<typeof useInbox.getState>>);
+    render(<BatchMoveModal />);
+    const checkbox = screen.getByRole('checkbox') as HTMLInputElement;
+    expect(checkbox.checked).toBe(true);
+
+    fireEvent.click(checkbox);
+    expect(checkbox.checked).toBe(false);
+    const confirmBtn = screen.getByRole('button', { name: /건 이동/ });
+    expect(confirmBtn).toBeDisabled();
+  });
+
+  it('확인 클릭 → acceptBatchAssignments 호출 후 modal 닫힘', async () => {
+    const mockAccept = vi.fn(async () => {});
+    useInbox.setState({
+      batchClassifyResult: {
+        assignments: [
+          { noteId: 'n1', notebookId: 'nb1', notebookName: '업무' }
+        ]
+      },
+      notes: [{ ...baseNote, id: 'n1' }],
+      acceptBatchAssignments: mockAccept
+    } as Partial<ReturnType<typeof useInbox.getState>>);
+    render(<BatchMoveModal />);
+    const confirmBtn = screen.getByRole('button', { name: /건 이동/ });
+    fireEvent.click(confirmBtn);
+    await waitFor(() => {
+      expect(mockAccept).toHaveBeenCalledWith([{ noteId: 'n1', notebookId: 'nb1' }]);
+    });
+  });
+});

tests/unit/ConflictModal.test.tsx

@@ -0,0 +1,83 @@
+// @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';
+import React from 'react';
+
+const { mockListConflicts, mockResolveConflict } = vi.hoisted(() => ({
+  mockListConflicts: vi.fn(),
+  mockResolveConflict: vi.fn()
+}));
+
+vi.mock('../../src/renderer/inbox/api.js', () => ({
+  inboxApi: { listConflicts: mockListConflicts, resolveConflict: mockResolveConflict }
+}));
+
+import { ConflictModal } from '../../src/renderer/inbox/components/ConflictModal';
+
+describe('ConflictModal', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    cleanup();
+    mockListConflicts.mockResolvedValue([
+      { path: 'notes/n1.md', localText: 'local A', remoteText: 'remote A' },
+      { path: 'notes/n2.md', localText: 'local B', remoteText: 'remote B' }
+    ]);
+    mockResolveConflict.mockResolvedValue({ ok: true });
+  });
+
+  it('open 시 listConflicts 호출 + 양 conflict preview 표시', async () => {
+    render(<ConflictModal onClose={() => {}} onResolved={() => {}} />);
+    await waitFor(() => screen.getByText(/local A/));
+    expect(screen.getByText(/local A/)).toBeInTheDocument();
+    expect(screen.getByText(/remote A/)).toBeInTheDocument();
+    expect(screen.getByText(/local B/)).toBeInTheDocument();
+    // path 가 표시됨 (Cut E final review fix — noteId → path)
+    expect(screen.getByText('notes/n1.md')).toBeInTheDocument();
+  });
+
+  it('내 것 사용 클릭 → resolveConflict(path, "local") 호출', async () => {
+    render(<ConflictModal onClose={() => {}} onResolved={() => {}} />);
+    await waitFor(() => screen.getByText(/local A/));
+    const buttons = screen.getAllByRole('button', { name: /내 것 사용/ });
+    fireEvent.click(buttons[0]!);
+    await waitFor(() => {
+      expect(mockResolveConflict).toHaveBeenCalledWith('notes/n1.md', 'local');
+    });
+  });
+
+  it('마지막 conflict 해결 → onResolved + onClose 호출', async () => {
+    mockListConflicts.mockResolvedValueOnce([{ path: 'notes/n1.md', localText: 'a', remoteText: 'b' }]);
+    const onResolved = vi.fn();
+    const onClose = vi.fn();
+    render(<ConflictModal onClose={onClose} onResolved={onResolved} />);
+    await waitFor(() => screen.getByRole('button', { name: /원격 사용/ }));
+    fireEvent.click(screen.getByRole('button', { name: /원격 사용/ }));
+    await waitFor(() => {
+      expect(onResolved).toHaveBeenCalled();
+      expect(onClose).toHaveBeenCalled();
+    });
+  });
+
+  it('각 conflict row 에 local/remote inline 설명 표시', async () => {
+    render(<ConflictModal onClose={() => {}} onResolved={() => {}} onOpenHelp={() => {}} />);
+    await waitFor(() => screen.getByText(/local A/));
+    expect(screen.getAllByText(/이 기기의 변경을 보존/).length).toBeGreaterThanOrEqual(2);
+    expect(screen.getAllByText(/원격의 변경을 가져오고/).length).toBeGreaterThanOrEqual(2);
+  });
+
+  it('"자세히 보기" 클릭 → onOpenHelp("main-conflict") 호출', async () => {
+    const onOpenHelp = vi.fn();
+    render(<ConflictModal onClose={() => {}} onResolved={() => {}} onOpenHelp={onOpenHelp} />);
+    await waitFor(() => screen.getByText(/local A/));
+    const links = screen.getAllByRole('button', { name: /자세히 보기/ });
+    fireEvent.click(links[0]!);
+    expect(onOpenHelp).toHaveBeenCalledWith('main-conflict');
+  });
+
+  it('onOpenHelp 미제공 → "자세히 보기" 링크 미렌더', async () => {
+    render(<ConflictModal onClose={() => {}} onResolved={() => {}} />);
+    await waitFor(() => screen.getByText(/local A/));
+    expect(screen.queryByRole('button', { name: /자세히 보기/ })).toBeNull();
+  });
+});

tests/unit/GitClient.fetch.test.ts

@@ -0,0 +1,51 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { GitClient } from '../../src/main/services/GitClient.js';
+
+describe('GitClient — fetch / rebase / conflict 메서드', () => {
+  let client: GitClient;
+  let runSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    client = new GitClient('/tmp/sync');
+    runSpy = vi.spyOn(client, 'run');
+  });
+
+  it('fetch — git fetch origin 호출', async () => {
+    runSpy.mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 });
+    const r = await client.fetch();
+    expect(runSpy).toHaveBeenCalledWith(['fetch', 'origin']);
+    expect(r.exitCode).toBe(0);
+  });
+
+  it('rebaseOnto — git rebase origin/main', async () => {
+    runSpy.mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 });
+    const r = await client.rebaseOnto('origin/main');
+    expect(runSpy).toHaveBeenCalledWith(['rebase', 'origin/main']);
+    expect(r.exitCode).toBe(0);
+  });
+
+  it('rebaseAbort — git rebase --abort', async () => {
+    runSpy.mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 });
+    await client.rebaseAbort();
+    expect(runSpy).toHaveBeenCalledWith(['rebase', '--abort']);
+  });
+
+  it('hasUncommittedChanges — git status --porcelain 의 출력 있으면 true', async () => {
+    runSpy.mockResolvedValueOnce({ stdout: ' M notes/abc.md\n', stderr: '', exitCode: 0 });
+    expect(await client.hasUncommittedChanges()).toBe(true);
+
+    runSpy.mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 });
+    expect(await client.hasUncommittedChanges()).toBe(false);
+  });
+
+  it('listConflicts — git diff --name-only --diff-filter=U 결과 파싱', async () => {
+    runSpy.mockResolvedValueOnce({
+      stdout: 'notes/aaa.md\nnotes/bbb.md\n',
+      stderr: '',
+      exitCode: 0
+    });
+    const r = await client.listConflicts();
+    expect(runSpy).toHaveBeenCalledWith(['diff', '--name-only', '--diff-filter=U']);
+    expect(r).toEqual(['notes/aaa.md', 'notes/bbb.md']);
+  });
+});

tests/unit/ImportService.applySyncFromDir.test.ts

@@ -0,0 +1,107 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import Database from 'better-sqlite3';
+import { mkdtemp, writeFile, mkdir, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { runMigrations } from '@main/db/migrations/index.js';
+import { NoteRepository } from '@main/repository/NoteRepository.js';
+import { ImportService } from '@main/services/ImportService.js';
+import { MediaStore } from '@main/services/MediaStore.js';
+
+describe('ImportService.applySyncFromDir', () => {
+  let db: Database.Database;
+  let repo: NoteRepository;
+  let svc: ImportService;
+  let workDir: string;
+
+  beforeEach(async () => {
+    db = new Database(':memory:');
+    db.pragma('foreign_keys = ON');
+    runMigrations(db);
+    repo = new NoteRepository(db);
+    workDir = await mkdtemp(join(tmpdir(), 'inkling-sync-'));
+    const mediaStore = new MediaStore(workDir);
+    svc = new ImportService(repo, mediaStore);
+  });
+
+  afterEach(async () => {
+    db.close();
+    await rm(workDir, { recursive: true, force: true });
+  });
+
+  it('inserts new notes and reports changedCount', async () => {
+    const notesDir = join(workDir, 'notes');
+    await mkdir(notesDir, { recursive: true });
+    await writeFile(
+      join(notesDir, 'a.md'),
+      `---\nid: 00000000-0000-0000-0000-000000000001\ncreated_at: 2026-05-09T00:00:00Z\nupdated_at: 2026-05-10T00:00:00Z\ntitle: title\ntitle_source: ai\nsummary: summary\nsummary_source: ai\nstatus: active\ninkling_export_version: 1\n---\n\n# title\n\n> summary\n\nbody\n`
+    );
+    const r = await svc.applySyncFromDir(workDir);
+    expect(r.changedCount).toBe(1);
+    const note = repo.findById('00000000-0000-0000-0000-000000000001');
+    expect(note?.rawText).toBe('body');
+  });
+
+  it('skips unchanged notes (no changedCount increment)', async () => {
+    const created = repo.create({ rawText: 'body' });
+    db.prepare(`UPDATE notes SET updated_at=? WHERE id=?`).run('2026-05-15T00:00:00Z', created.id);
+    const notesDir = join(workDir, 'notes');
+    await mkdir(notesDir, { recursive: true });
+    await writeFile(
+      join(notesDir, 'a.md'),
+      `---\nid: ${created.id}\ncreated_at: 2026-05-09T00:00:00Z\nupdated_at: 2026-05-10T00:00:00Z\ntitle: t\ntitle_source: ai\nsummary: s\nsummary_source: ai\nstatus: active\ninkling_export_version: 1\n---\n\n# t\n\n> s\n\nbody\n`
+    );
+    const r = await svc.applySyncFromDir(workDir);
+    expect(r.changedCount).toBe(0);
+  });
+
+  it('returns changedCount=0 for an empty notes directory', async () => {
+    const notesDir = join(workDir, 'notes');
+    await mkdir(notesDir, { recursive: true });
+    const r = await svc.applySyncFromDir(workDir);
+    expect(r.changedCount).toBe(0);
+  });
+
+  it('updates a note when source updatedAt is newer', async () => {
+    const created = repo.create({ rawText: 'old body' });
+    db.prepare(`UPDATE notes SET updated_at=? WHERE id=?`).run('2026-05-01T00:00:00Z', created.id);
+    const notesDir = join(workDir, 'notes');
+    await mkdir(notesDir, { recursive: true });
+    await writeFile(
+      join(notesDir, 'a.md'),
+      `---\nid: ${created.id}\ncreated_at: 2026-05-09T00:00:00Z\nupdated_at: 2026-05-10T00:00:00Z\ntitle: t\ntitle_source: ai\nsummary: s\nsummary_source: ai\nstatus: active\ninkling_export_version: 1\n---\n\n# t\n\n> s\n\nnew body\n`
+    );
+    const r = await svc.applySyncFromDir(workDir);
+    expect(r.changedCount).toBe(1);
+    const note = repo.findById(created.id);
+    expect(note?.rawText).toBe('new body');
+  });
+
+  it('preserves status field from frontmatter (archived coerced to completed — v0.4 Task 16)', async () => {
+    const notesDir = join(workDir, 'notes');
+    await mkdir(notesDir, { recursive: true });
+    await writeFile(
+      join(notesDir, 'a.md'),
+      `---\nid: 00000000-0000-0000-0000-000000000002\ncreated_at: 2026-05-09T00:00:00Z\nupdated_at: 2026-05-10T00:00:00Z\ntitle: t\ntitle_source: ai\nsummary: s\nsummary_source: ai\nstatus: archived\nstatus_changed_at: 2026-05-08T00:00:00Z\nmove_reason: done\ninkling_export_version: 1\n---\n\n# t\n\n> s\n\nbody\n`
+    );
+    await svc.applySyncFromDir(workDir);
+    const note = repo.findById('00000000-0000-0000-0000-000000000002');
+    // archived → completed coerce (m008 와 동일 정책, NoteStatus 에서 archived 삭제됨).
+    expect(note?.status).toBe('completed');
+    expect(note?.statusChangedAt).toBe('2026-05-08T00:00:00Z');
+    expect(note?.moveReason).toBe('done');
+  });
+
+  it('preserves dueDate from frontmatter', async () => {
+    const notesDir = join(workDir, 'notes');
+    await mkdir(notesDir, { recursive: true });
+    await writeFile(
+      join(notesDir, 'a.md'),
+      `---\nid: 00000000-0000-0000-0000-000000000003\ncreated_at: 2026-05-09T00:00:00Z\nupdated_at: 2026-05-10T00:00:00Z\ntitle: t\ntitle_source: ai\nsummary: s\nsummary_source: ai\nstatus: active\ndue_date: 2026-06-01\ndue_date_source: user\ninkling_export_version: 1\n---\n\n# t\n\n> s\n\nbody\n`
+    );
+    await svc.applySyncFromDir(workDir);
+    const note = repo.findById('00000000-0000-0000-0000-000000000003');
+    expect(note?.dueDate).toBe('2026-06-01');
+    expect(note?.dueDateEditedByUser).toBe(true);
+  });
+});

tests/unit/ImportService.test.ts

@@ -34,6 +34,12 @@ function buildExportNote(overrides: Partial<ExportNote> = {}): ExportNote {
     aiGeneratedAt: '2026-04-25T14:23:34.000Z',
     userIntent: null,
     intentPromptedAt: null,
+    // v0.3.0 Cut E — frontmatter round-trip 5 필드 (Cut B status + Cut C dueDate).
+    status: 'active',
+    statusChangedAt: null,
+    moveReason: null,
+    dueDate: null,
+    dueDateEditedByUser: false,
     tags: [{ name: 'pr', source: 'ai' }],
     media: [],
     ...overrides

tests/unit/LocalOllamaProvider.test.ts

@@ -45,13 +45,47 @@ describe('LocalOllamaProvider', () => {
     expect(parsed.prompt).toContain('Prefer reusing');
   });
 
-  it('generate throws on non-JSON', async () => {
+  it('v0.3.14 — generate falls back to placeholder when JSON unparseable', async () => {
+    // 이전엔 throw 했지만 schema graceful coerce 추가 후 placeholder 채워서 통과.
+    // truncated / repetition-loop 응답에서 사용자 데이터 (raw_text) 무손실 보존.
     mock.get('http://localhost:11434').intercept({ path: '/api/generate', method: 'POST' }).reply(200, {
       response: 'not json'
     });
-    await expect(
-      new LocalOllamaProvider().generate({ text: 'x', todayKst: '2026-04-26', dueDateCandidates: [] })
-    ).rejects.toThrow(/json/i);
+    const r = await new LocalOllamaProvider().generate({ text: 'x', todayKst: '2026-04-26', dueDateCandidates: [] });
+    expect(r.title).toBe('(첨부 메모)');
+    expect(r.summary.length).toBeGreaterThan(0);
+  });
+
+  it('v0.3.14 — body 에 repeat_penalty 포함 (repetition loop 방지)', async () => {
+    let capturedBody: string = '';
+    mock.get('http://localhost:11434').intercept({
+      path: '/api/generate', method: 'POST'
+    }).reply((opts) => {
+      capturedBody = opts.body as string;
+      return { statusCode: 200, data: JSON.stringify({
+        response: JSON.stringify({ title: '회의', summary: 'a\nb\nc', tags: [] })
+      }) };
+    });
+    await new LocalOllamaProvider().generate({ text: 'x', todayKst: '2026-04-26', dueDateCandidates: [] });
+    const parsed = JSON.parse(capturedBody) as { options: { repeat_penalty: number } };
+    expect(parsed.options.repeat_penalty).toBe(1.15);
+  });
+
+  it('v0.3.11 — generate extracts JSON from markdown fence', async () => {
+    // vision model 이 ```json ... ``` 형태로 응답하는 경우 fallback 으로 추출.
+    mock.get('http://localhost:11434').intercept({ path: '/api/generate', method: 'POST' }).reply(200, {
+      response: '```json\n{"title":"회의","summary":"a\\nb\\nc","tags":["meet"]}\n```'
+    });
+    const r = await new LocalOllamaProvider().generate({ text: 'x', todayKst: '2026-04-26', dueDateCandidates: [] });
+    expect(r.title).toBe('회의');
+  });
+
+  it('v0.3.11 — generate extracts JSON when prose 가 앞뒤로 섞임', async () => {
+    mock.get('http://localhost:11434').intercept({ path: '/api/generate', method: 'POST' }).reply(200, {
+      response: 'Here is the response:\n{"title":"회의","summary":"a\\nb\\nc","tags":[]}\nDone.'
+    });
+    const r = await new LocalOllamaProvider().generate({ text: 'x', todayKst: '2026-04-26', dueDateCandidates: [] });
+    expect(r.title).toBe('회의');
   });
 
   it('generate aborts on timeout', async () => {
@@ -109,4 +143,96 @@ describe('LocalOllamaProvider', () => {
     const provider = new LocalOllamaProvider({ model: 'gemma4:26b' });
     expect(provider.name).toBe('local-ollama/gemma4:26b');
   });
+
+  describe('healthCheck PII reason masking', () => {
+    it('classifies ECONNREFUSED as network', async () => {
+      mock.get('http://192.168.1.5:11434').intercept({ path: '/api/tags', method: 'GET' })
+        .replyWithError(new Error('connect ECONNREFUSED 192.168.1.5:11434'));
+      const provider = new LocalOllamaProvider({ endpoint: 'http://192.168.1.5:11434' });
+      const h = await provider.healthCheck();
+      expect(h.ok).toBe(false);
+      expect(h.reason).toBe('unreachable:network');
+      expect(h.reason).not.toContain('192.168.1.5');
+    });
+
+    it('classifies AbortError/timeout as timeout', async () => {
+      mock.get('http://localhost:11434').intercept({ path: '/api/tags', method: 'GET' })
+        .replyWithError(new Error('The operation was aborted due to timeout'));
+      const h = await new LocalOllamaProvider().healthCheck();
+      expect(h.ok).toBe(false);
+      expect(h.reason).toBe('unreachable:timeout');
+    });
+
+    it('classifies ENOTFOUND as dns', async () => {
+      mock.get('http://nonexistent.local:11434').intercept({ path: '/api/tags', method: 'GET' })
+        .replyWithError(new Error('getaddrinfo ENOTFOUND nonexistent.local'));
+      const provider = new LocalOllamaProvider({ endpoint: 'http://nonexistent.local:11434' });
+      const h = await provider.healthCheck();
+      expect(h.ok).toBe(false);
+      expect(h.reason).toBe('unreachable:dns');
+      expect(h.reason).not.toContain('nonexistent.local');
+    });
+
+    it('falls back to other for unknown errors', async () => {
+      mock.get('http://localhost:11434').intercept({ path: '/api/tags', method: 'GET' })
+        .replyWithError(new Error('something weird happened'));
+      const h = await new LocalOllamaProvider().healthCheck();
+      expect(h.ok).toBe(false);
+      expect(h.reason).toBe('unreachable:other');
+    });
+  });
+
+  describe('vision path (v0.3.1 Cut F)', () => {
+    it('visionModel + images → body.images + model=visionModel + buildVisionPrompt', async () => {
+      let capturedBody: string = '';
+      mock.get('http://x').intercept({ path: '/api/generate', method: 'POST' }).reply((opts) => {
+        capturedBody = opts.body as string;
+        return { statusCode: 200, data: JSON.stringify({
+          response: JSON.stringify({ title: '비전테스트', summary: 'a\nb\nc', tags: [], due_date: null })
+        }) };
+      });
+      const provider = new LocalOllamaProvider({ endpoint: 'http://x', model: 'gemma4:e4b' });
+      await provider.generate(
+        { text: 'hi', todayKst: '2026-05-10', dueDateCandidates: [], images: [{ base64: 'AAAA', mime: 'image/png' }] },
+        { visionModel: 'gemma3:12b-vision' }
+      );
+      const parsed = JSON.parse(capturedBody) as { model: string; prompt: string; images?: string[] };
+      expect(parsed.model).toBe('gemma3:12b-vision');
+      expect(parsed.prompt).toContain('이미지');
+      expect(parsed.images).toEqual(['AAAA']);
+    });
+
+    it('visionModel 있어도 images 없으면 text-only (model = this.model, no body.images)', async () => {
+      let capturedBody: string = '';
+      mock.get('http://x').intercept({ path: '/api/generate', method: 'POST' }).reply((opts) => {
+        capturedBody = opts.body as string;
+        return { statusCode: 200, data: JSON.stringify({
+          response: JSON.stringify({ title: '텍스트전용', summary: 'a\nb\nc', tags: [], due_date: null })
+        }) };
+      });
+      const provider = new LocalOllamaProvider({ endpoint: 'http://x', model: 'gemma4:e4b' });
+      await provider.generate(
+        { text: 'hi', todayKst: '2026-05-10', dueDateCandidates: [] },
+        { visionModel: 'gemma3:12b-vision' }
+      );
+      const parsed = JSON.parse(capturedBody) as { model: string; images?: string[] };
+      expect(parsed.model).toBe('gemma4:e4b');
+      expect(parsed.images).toBeUndefined();
+    });
+
+    it('opts 미전달 → 기존 text-only (회귀)', async () => {
+      let capturedBody: string = '';
+      mock.get('http://x').intercept({ path: '/api/generate', method: 'POST' }).reply((opts) => {
+        capturedBody = opts.body as string;
+        return { statusCode: 200, data: JSON.stringify({
+          response: JSON.stringify({ title: '기본텍스트', summary: 'a\nb\nc', tags: [], due_date: null })
+        }) };
+      });
+      const provider = new LocalOllamaProvider({ endpoint: 'http://x', model: 'gemma4:e4b' });
+      await provider.generate({ text: 'hi', todayKst: '2026-05-10', dueDateCandidates: [] });
+      const parsed = JSON.parse(capturedBody) as { model: string; images?: string[] };
+      expect(parsed.model).toBe('gemma4:e4b');
+      expect(parsed.images).toBeUndefined();
+    });
+  });
 });

tests/unit/MoveStatusModal.test.tsx

@@ -26,19 +26,20 @@ describe('MoveStatusModal', () => {
     cleanup();
   });
 
-  it('renders reason textarea + 4 buttons + AI classify button', () => {
+  it('renders reason textarea + 3 buttons + AI classify button (v0.4 — 보관 제거)', () => {
     render(
       <MoveStatusModal
         noteId="n1"
         rawText="t"
         summary=""
+        currentStatus="active"
         onClose={vi.fn()}
         onMoved={vi.fn()}
       />
     );
     expect(screen.getByRole('textbox')).toBeInTheDocument();
     expect(screen.getByRole('button', { name: '완료' })).toBeInTheDocument();
-    expect(screen.getByRole('button', { name: '보관' })).toBeInTheDocument();
+    expect(screen.queryByRole('button', { name: '보관' })).toBeNull();
     expect(screen.getByRole('button', { name: '휴지통' })).toBeInTheDocument();
     expect(screen.getByRole('button', { name: /AI 자동 분류/ })).toBeInTheDocument();
   });
@@ -50,6 +51,7 @@ describe('MoveStatusModal', () => {
         noteId="n1"
         rawText="t"
         summary=""
+        currentStatus="active"
         onClose={vi.fn()}
         onMoved={onMoved}
       />
@@ -69,6 +71,7 @@ describe('MoveStatusModal', () => {
         noteId="n1"
         rawText="t"
         summary=""
+        currentStatus="active"
         onClose={vi.fn()}
         onMoved={onMoved}
       />
@@ -81,6 +84,78 @@ describe('MoveStatusModal', () => {
     await waitFor(() => expect(onMoved).toHaveBeenCalledWith('completed', '결재 끝'));
   });
 
+  it('currentStatus=completed → Inbox/휴지통 노출, 완료/보관 미노출 (v0.4 — 보관 제거)', () => {
+    render(
+      <MoveStatusModal
+        noteId="n1"
+        rawText="t"
+        summary=""
+        currentStatus="completed"
+        onClose={vi.fn()}
+        onMoved={vi.fn()}
+      />
+    );
+    expect(screen.getByRole('button', { name: 'Inbox' })).toBeInTheDocument();
+    expect(screen.queryByRole('button', { name: '보관' })).toBeNull();
+    expect(screen.getByRole('button', { name: '휴지통' })).toBeInTheDocument();
+    expect(screen.queryByRole('button', { name: '완료' })).toBeNull();
+  });
+
+  // v0.4 Task 16 — currentStatus=archived 는 NoteStatus 에서 제거됨. 테스트 제거.
+
+  it('currentStatus=trashed → Inbox/완료 노출, 휴지통/보관 미노출 (v0.4 — 보관 제거)', () => {
+    render(
+      <MoveStatusModal
+        noteId="n1"
+        rawText="t"
+        summary=""
+        currentStatus="trashed"
+        onClose={vi.fn()}
+        onMoved={vi.fn()}
+      />
+    );
+    expect(screen.getByRole('button', { name: 'Inbox' })).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: '완료' })).toBeInTheDocument();
+    expect(screen.queryByRole('button', { name: '보관' })).toBeNull();
+    expect(screen.queryByRole('button', { name: '휴지통' })).toBeNull();
+  });
+
+  it('Escape key → onClose 호출', () => {
+    const onClose = vi.fn();
+    render(
+      <MoveStatusModal
+        noteId="n1"
+        rawText="t"
+        summary=""
+        currentStatus="active"
+        onClose={onClose}
+        onMoved={vi.fn()}
+      />
+    );
+    fireEvent.keyDown(document, { key: 'Escape' });
+    expect(onClose).toHaveBeenCalled();
+  });
+
+  it('overlay 클릭 → onClose, modal body 클릭 → 무반응', () => {
+    const onClose = vi.fn();
+    render(
+      <MoveStatusModal
+        noteId="n1"
+        rawText="t"
+        summary=""
+        currentStatus="active"
+        onClose={onClose}
+        onMoved={vi.fn()}
+      />
+    );
+    // body 클릭 (textarea) → onClose 호출 안 됨
+    fireEvent.click(screen.getByRole('textbox'));
+    expect(onClose).not.toHaveBeenCalled();
+    // overlay (dialog) 클릭 → onClose
+    fireEvent.click(screen.getByRole('dialog', { name: '이동' }));
+    expect(onClose).toHaveBeenCalled();
+  });
+
   it('빈 사유 → null reason 전달', async () => {
     const onMoved = vi.fn();
     render(
@@ -88,11 +163,12 @@ describe('MoveStatusModal', () => {
         noteId="n1"
         rawText="t"
         summary=""
+        currentStatus="active"
         onClose={vi.fn()}
         onMoved={onMoved}
       />
     );
-    fireEvent.click(screen.getByRole('button', { name: '보관' }));
-    await waitFor(() => expect(mockSetStatus).toHaveBeenCalledWith('n1', 'archived', null));
+    fireEvent.click(screen.getByRole('button', { name: '완료' }));
+    await waitFor(() => expect(mockSetStatus).toHaveBeenCalledWith('n1', 'completed', null));
   });
 });

tests/unit/NoteCard.test.tsx

@@ -2,16 +2,17 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import '@testing-library/jest-dom/vitest';
 import { render, screen, fireEvent, cleanup, waitFor } from '@testing-library/react';
-import type { Note } from '@shared/types';
+import type { Note, Notebook } from '@shared/types';
 
-const { mockOpenMedia, mockSetStatus, mockClassify, mockUpdateRawText } = vi.hoisted(() => ({
+const { mockOpenMedia, mockSetStatus, mockClassify, mockUpdateRawText, mockMoveNoteToNotebook } = vi.hoisted(() => ({
   mockOpenMedia: vi.fn(async () => ({ ok: true })),
   mockSetStatus: vi.fn(async () => ({ ok: true as const })),
   mockClassify: vi.fn(async () => ({
     recommended: 'archived' as const,
     rationale: 'stub'
   })),
-  mockUpdateRawText: vi.fn(async () => ({ ok: true as const }))
+  mockUpdateRawText: vi.fn(async () => ({ ok: true as const })),
+  mockMoveNoteToNotebook: vi.fn(async () => {})
 }));
 
 vi.mock('../../src/renderer/inbox/api.js', () => ({
@@ -32,10 +33,26 @@ vi.mock('../../src/renderer/inbox/api.js', () => ({
   }
 }));
 
+const mockRefreshMeta = vi.fn();
+
+// Notebooks used across notebook-chip tests.
+const stubNotebooks: Notebook[] = [
+  { id: 'nb-1', name: '회사', color: '#4a90d9', createdAt: '2026-01-01T00:00:00Z', updatedAt: '2026-01-01T00:00:00Z', noteCount: 1 },
+  { id: 'nb-2', name: '개인', color: '#e67e22', createdAt: '2026-01-01T00:00:00Z', updatedAt: '2026-01-01T00:00:00Z', noteCount: 0 }
+];
+
 vi.mock('../../src/renderer/inbox/store.js', () => ({
   useInbox: Object.assign(
-    () => ({}),
-    { getState: () => ({ setTagFilter: vi.fn() }) }
+    // Selector-aware: if selector is a function, call it with the mock state.
+    (selector?: (s: unknown) => unknown) => {
+      const state = {
+        notebooks: stubNotebooks,
+        moveNoteToNotebook: mockMoveNoteToNotebook
+      };
+      if (typeof selector === 'function') return selector(state);
+      return state;
+    },
+    { getState: () => ({ setTagFilter: vi.fn(), refreshMeta: mockRefreshMeta }) }
   )
 }));
 
@@ -68,7 +85,8 @@ const baseNote: Note = {
   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 }
-  ]
+  ],
+  notebookId: 'nb-default'
 };
 
 describe('NoteCard — image rendering', () => {
@@ -127,34 +145,36 @@ describe('NoteCard — ai_status=disabled fallback (v0.2.9 Cut B Task 13)', () =
   });
 });
 
-describe('NoteCard — 이동 메뉴 (v0.2.9 Cut B Task 6)', () => {
+describe('NoteCard — 이동 버튼', () => {
   beforeEach(() => {
     vi.clearAllMocks();
     cleanup();
   });
 
-  it('이동 ▾ 클릭 → 현재 status 외 3개 목적지 메뉴 표시', () => {
-    // baseNote.status = 'active' → 완료/보관/휴지통 만 표시
+  it('이동 클릭 → MoveStatusModal 열림', () => {
     render(<NoteCard note={baseNote} onUpdated={() => {}} mode="inbox" />);
     fireEvent.click(screen.getByRole('button', { name: '이동' }));
-    expect(screen.getByRole('button', { name: '완료로 이동' })).toBeInTheDocument();
-    expect(screen.getByRole('button', { name: '보관으로 이동' })).toBeInTheDocument();
-    expect(screen.getByRole('button', { name: '휴지통으로 이동' })).toBeInTheDocument();
-    expect(screen.queryByRole('button', { name: '활성으로 이동' })).toBeNull();
+    expect(screen.getByRole('dialog', { name: '이동' })).toBeInTheDocument();
   });
 
-  it('메뉴 항목 클릭 → MoveStatusModal 열림 + 확정 시 setStatus 호출', async () => {
+  it('Modal 내부 "완료" 버튼 → setStatus 호출 + onUpdated + onDeleted + refreshMeta', async () => {
     const onUpdated = vi.fn();
-    render(<NoteCard note={baseNote} onUpdated={onUpdated} mode="inbox" />);
+    const onDeleted = vi.fn();
+    render(
+      <NoteCard
+        note={baseNote}
+        onUpdated={onUpdated}
+        onDeleted={onDeleted}
+        mode="inbox"
+      />
+    );
     fireEvent.click(screen.getByRole('button', { name: '이동' }));
-    fireEvent.click(screen.getByRole('button', { name: '완료로 이동' }));
-    // Modal 의 dialog role 등장
-    expect(screen.getByRole('dialog', { name: '이동' })).toBeInTheDocument();
-    // Modal 내부의 "완료" 버튼 클릭 → setStatus
     fireEvent.click(screen.getByRole('button', { name: '완료' }));
     await waitFor(() => {
       expect(mockSetStatus).toHaveBeenCalledWith('n1', 'completed', null);
       expect(onUpdated).toHaveBeenCalled();
+      expect(onDeleted).toHaveBeenCalled();
+      expect(mockRefreshMeta).toHaveBeenCalled();
     });
   });
 });
@@ -186,3 +206,34 @@ describe('NoteCard — raw_text editing', () => {
     expect(last.rawText).toBe('new');
   });
 });
+
+describe('NoteCard — notebook chip (Task 17)', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    cleanup();
+  });
+
+  it('현재 notebook 이름 chip 렌더링', () => {
+    render(<NoteCard note={{ ...baseNote, notebookId: 'nb-1' }} onUpdated={vi.fn()} mode="inbox" />);
+    expect(screen.getByTitle('다른 노트북으로 이동')).toBeInTheDocument();
+    expect(screen.getByTitle('다른 노트북으로 이동').textContent).toContain('회사');
+  });
+
+  it('chip 클릭 → 다른 notebook 목록 dropdown', () => {
+    render(<NoteCard note={{ ...baseNote, notebookId: 'nb-1' }} onUpdated={vi.fn()} mode="inbox" />);
+    fireEvent.click(screen.getByTitle('다른 노트북으로 이동'));
+    // 현재 nb-1('회사') 는 제외, nb-2('개인') 만 보임.
+    expect(screen.getByText('개인')).toBeInTheDocument();
+    // chip 자체 text 는 "📓 회사 ▾" 이라 정확 매칭 X → regex 로 chip 안에만 '회사' 존재 확인.
+    expect(screen.queryAllByText(/회사/).length).toBe(1);
+  });
+
+  it('dropdown 의 notebook 클릭 → store.moveNoteToNotebook 호출', async () => {
+    render(<NoteCard note={{ ...baseNote, notebookId: 'nb-1' }} onUpdated={vi.fn()} mode="inbox" />);
+    fireEvent.click(screen.getByTitle('다른 노트북으로 이동'));
+    fireEvent.click(screen.getByText('개인'));
+    await waitFor(() => {
+      expect(mockMoveNoteToNotebook).toHaveBeenCalledWith('n1', 'nb-2');
+    });
+  });
+});

tests/unit/NoteRepository.reviewAggregate.test.ts

@@ -0,0 +1,72 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import Database from 'better-sqlite3';
+import { runMigrations } from '../../src/main/db/migrations/index.js';
+import { NoteRepository } from '../../src/main/repository/NoteRepository.js';
+
+describe('NoteRepository.reviewAggregate', () => {
+  let db: Database.Database;
+  let repo: NoteRepository;
+
+  beforeEach(() => {
+    db = new Database(':memory:');
+    db.pragma('foreign_keys = ON');
+    runMigrations(db);
+    repo = new NoteRepository(db);
+  });
+
+  afterEach(() => { db.close(); });
+
+  it('daily — 오늘 KST 자정 이후 노트만 카운트', () => {
+    const now = new Date('2026-05-10T05:00:00Z'); // KST 14:00
+    db.prepare(`INSERT INTO notes (id, raw_text, ai_status, created_at, updated_at, status)
+                VALUES (?, ?, 'done', ?, ?, 'active')`).run('today', '오늘 메모', '2026-05-10T00:30:00Z', '2026-05-10T00:30:00Z');
+    db.prepare(`INSERT INTO notes (id, raw_text, ai_status, created_at, updated_at, status)
+                VALUES (?, ?, 'done', ?, ?, 'active')`).run('yesterday', '어제 메모', '2026-05-09T10:00:00Z', '2026-05-09T10:00:00Z');
+    const r = repo.reviewAggregate('daily', now);
+    expect(r.totalCount).toBe(1);
+    expect(r.recentNotes).toHaveLength(1);
+    expect(r.recentNotes[0]!.id).toBe('today');
+  });
+
+  it('weekly — 7일 전 KST 자정 이후', () => {
+    const now = new Date('2026-05-10T05:00:00Z');
+    db.prepare(`INSERT INTO notes (id, raw_text, ai_status, created_at, updated_at, status)
+                VALUES (?, ?, 'done', ?, ?, 'active')`).run('5dago', '5일 전', '2026-05-05T00:00:00Z', '2026-05-05T00:00:00Z');
+    db.prepare(`INSERT INTO notes (id, raw_text, ai_status, created_at, updated_at, status)
+                VALUES (?, ?, 'done', ?, ?, 'active')`).run('10dago', '10일 전', '2026-04-30T00:00:00Z', '2026-04-30T00:00:00Z');
+    const r = repo.reviewAggregate('weekly', now);
+    expect(r.totalCount).toBe(1);
+  });
+
+  it('trashed 제외', () => {
+    const now = new Date('2026-05-10T05:00:00Z');
+    const a = repo.create({ rawText: '활성' });
+    const b = repo.create({ rawText: '버린' });
+    repo.setStatus(b.id, 'trashed', null);
+    const r = repo.reviewAggregate('monthly', now);
+    expect(r.recentNotes.map((n) => n.id)).toContain(a.id);
+    expect(r.recentNotes.map((n) => n.id)).not.toContain(b.id);
+  });
+
+  it('tagCounts — period 안 노트의 태그만 DESC', () => {
+    const now = new Date('2026-05-10T05:00:00Z');
+    const a = repo.create({ rawText: 'a' });
+    const b = repo.create({ rawText: 'b' });
+    repo.updateAiResult(a.id, { title: 't', summary: 's', tags: ['x', 'y'], provider: 'p' });
+    repo.updateAiResult(b.id, { title: 't', summary: 's', tags: ['x'], provider: 'p' });
+    const r = repo.reviewAggregate('monthly', now);
+    expect(r.tagCounts[0]).toEqual({ tag: 'x', count: 2 });
+    expect(r.tagCounts[1]).toEqual({ tag: 'y', count: 1 });
+  });
+
+  it('dueProgress — passed / pending KST today 기준', () => {
+    const now = new Date('2026-05-10T05:00:00Z');
+    const a = repo.create({ rawText: 'a' });
+    const b = repo.create({ rawText: 'b' });
+    repo.create({ rawText: 'c' }); // due 없음 → 카운트 X
+    repo.setDueDate(a.id, '2026-05-01'); // passed
+    repo.setDueDate(b.id, '2026-05-15'); // pending
+    const r = repo.reviewAggregate('monthly', now);
+    expect(r.dueProgress).toEqual({ total: 2, passed: 1, pending: 1 });
+  });
+});

tests/unit/NoteRepository.search.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import Database from 'better-sqlite3';
+import { runMigrations } from '../../src/main/db/migrations/index.js';
+import { NoteRepository } from '../../src/main/repository/NoteRepository.js';
+
+describe('NoteRepository.search — FTS5', () => {
+  let db: Database.Database;
+  let repo: NoteRepository;
+
+  beforeEach(() => {
+    db = new Database(':memory:');
+    db.pragma('foreign_keys = ON');
+    runMigrations(db);
+    repo = new NoteRepository(db);
+    const a = repo.create({ rawText: '오늘 월요일 회의 정리' });
+    repo.updateAiResult(a.id, { title: '회의록', summary: '월요일', tags: ['기획', '회의'], provider: 'p' });
+    const b = repo.create({ rawText: '결재 요청 본문' });
+    repo.updateAiResult(b.id, { title: '결재', summary: '요청서', tags: ['결재'], provider: 'p' });
+    const c = repo.create({ rawText: '버려진 메모' });
+    repo.setStatus(c.id, 'trashed', null);
+  });
+
+  afterEach(() => { db.close(); });
+
+  it('빈 query → 빈 배열', () => {
+    expect(repo.search('')).toEqual([]);
+    expect(repo.search('   ')).toEqual([]);
+  });
+
+  it('keyword 매칭 → hydrated Note', () => {
+    const r = repo.search('월요일');
+    expect(r.length).toBeGreaterThan(0);
+    const titles = r.map((n) => n.aiTitle);
+    expect(titles).toContain('회의록');
+  });
+
+  it('multi-token implicit AND', () => {
+    const r1 = repo.search('회의 월요일');
+    expect(r1.length).toBeGreaterThan(0);
+    const r2 = repo.search('회의 결재'); // 동시 매칭 노트 없음
+    expect(r2).toEqual([]);
+  });
+
+  it('default 는 trashed 제외', () => {
+    const r = repo.search('버려진');
+    expect(r).toEqual([]);
+  });
+
+  it('status filter 명시 시 해당 status 만', () => {
+    const r = repo.search('버려진', { status: 'trashed' });
+    expect(r.length).toBe(1);
+  });
+
+  it('FTS5 special char 안전 처리', () => {
+    expect(() => repo.search('"회의*" (월요일):')).not.toThrow();
+  });
+});