oiiaw 0.1.0__tar.gz

oiiaw-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 zerossin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

oiiaw-0.1.0/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: oiiaw
+Version: 0.1.0
+Summary: Obsidian <-> iCloud sync bridge for Windows
+Author: zerossin
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/zerossin/oiiaw
+Project-URL: Repository, https://github.com/zerossin/oiiaw
+Project-URL: Issues, https://github.com/zerossin/oiiaw/issues
+Keywords: obsidian,icloud,sync,windows
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Win32 (MS Windows)
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: watchdog>=4.0.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: colorama>=0.4.6
+Requires-Dist: pystray>=0.19.5
+Requires-Dist: pillow>=10.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Dynamic: license-file
+
+# oiiaw
+
+Obsidian ↔ iCloud, Windows용 자동 동기화 도구.
+
+Obsidian을 iCloud Drive 폴더에서 직접 열면 저장할 때마다 충돌 파일이 생깁니다.
+oiiaw는 로컬 폴더와 iCloud 폴더를 백그라운드에서 대신 동기화해서 이 문제를 없애줍니다.
+
+## 설치
+
+1. [Python 3.11+](https://www.python.org/downloads/) 설치 — **"Add python.exe to PATH"** 체크
+2. 코드 받기:
+   ```
+   git clone https://github.com/zerossin/oiiaw.git
+   ```
+   git이 없다면 이 페이지 위쪽 **Code → Download ZIP** → 압축 풀기
+3. 받은 폴더에서 `cmd` 열고:
+   ```
+   pip install .
+   ```
+4. `oiiaw-setup` 실행 → 로컬 폴더 / iCloud 폴더 선택 → 설치
+
+## 사용법
+
+- Obsidian에서는 iCloud 폴더가 아닌 항상 **로컬 폴더**만 vault로 여세요.
+- 트레이 아이콘 색: 🔵 대기 · 🟠 동기화 중 · 🔴 충돌/에러
+- 트레이 클릭시 현재 상태와 최근 활동 목록이 뜹니다.
+- 트레이 우클릭 → 재시작으로 안전하게 다시 시작할 수 있습니다.
+- 트레이를 껐다면 `oiiaw-setup`을 다시 할 필요 없이 `oiiaw start`로
+  기존 설정 그대로 다시 켤 수 있습니다.
+- 터미널에서 `oiiaw status`로도 확인이 가능합니다.
+- 자동 시작 등록이 실패하면 `oiiaw-setup`을 관리자 권한으로 다시 실행하세요.
+
+## 고급: 설정 파일 직접 편집
+
+마법사 대신 `config.example.yaml`을 `config.yaml`로 복사해 경로를 채우고
+`oiiaw run -c config.yaml`로 실행할 수도 있습니다.

oiiaw-0.1.0/README.md

@@ -0,0 +1,36 @@
+# oiiaw
+
+Obsidian ↔ iCloud, Windows용 자동 동기화 도구.
+
+Obsidian을 iCloud Drive 폴더에서 직접 열면 저장할 때마다 충돌 파일이 생깁니다.
+oiiaw는 로컬 폴더와 iCloud 폴더를 백그라운드에서 대신 동기화해서 이 문제를 없애줍니다.
+
+## 설치
+
+1. [Python 3.11+](https://www.python.org/downloads/) 설치 — **"Add python.exe to PATH"** 체크
+2. 코드 받기:
+   ```
+   git clone https://github.com/zerossin/oiiaw.git
+   ```
+   git이 없다면 이 페이지 위쪽 **Code → Download ZIP** → 압축 풀기
+3. 받은 폴더에서 `cmd` 열고:
+   ```
+   pip install .
+   ```
+4. `oiiaw-setup` 실행 → 로컬 폴더 / iCloud 폴더 선택 → 설치
+
+## 사용법
+
+- Obsidian에서는 iCloud 폴더가 아닌 항상 **로컬 폴더**만 vault로 여세요.
+- 트레이 아이콘 색: 🔵 대기 · 🟠 동기화 중 · 🔴 충돌/에러
+- 트레이 클릭시 현재 상태와 최근 활동 목록이 뜹니다.
+- 트레이 우클릭 → 재시작으로 안전하게 다시 시작할 수 있습니다.
+- 트레이를 껐다면 `oiiaw-setup`을 다시 할 필요 없이 `oiiaw start`로
+  기존 설정 그대로 다시 켤 수 있습니다.
+- 터미널에서 `oiiaw status`로도 확인이 가능합니다.
+- 자동 시작 등록이 실패하면 `oiiaw-setup`을 관리자 권한으로 다시 실행하세요.
+
+## 고급: 설정 파일 직접 편집
+
+마법사 대신 `config.example.yaml`을 `config.yaml`로 복사해 경로를 채우고
+`oiiaw run -c config.yaml`로 실행할 수도 있습니다.

oiiaw-0.1.0/oiiaw/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

oiiaw-0.1.0/oiiaw/__main__.py

@@ -0,0 +1,125 @@
+import argparse
+import os
+import sys
+import time
+
+from .config import Config
+from .logger import Logger
+from .sync_engine import SyncEngine
+from .status_file import StatusReporter
+from .tray import TrayApp
+from .paths import default_config_path
+from .ui_assets import apply_window_icon, configure_windows_app_identity
+
+
+def _run(config_path):
+    configure_windows_app_identity()
+    config = Config.load(config_path)
+    logger = Logger(config.logs_dir, config.console_level, config.log_retention)
+
+    existing = StatusReporter.read(config.logs_dir)
+    if StatusReporter.is_fresh(existing, max_age=5.0):
+        message = f"oiiaw가 이미 실행 중입니다 (pid {existing['pid']}) — 중복 실행을 막기 위해 새로 시작하지 않습니다."
+        logger.error("START", message, level="important")
+        import tkinter as tk
+        from tkinter import messagebox
+        root = tk.Tk()
+        apply_window_icon(root)
+        root.withdraw()
+        messagebox.showerror("oiiaw", message)
+        root.destroy()
+        sys.exit(1)
+
+    for problem in config.validate():
+        if problem.blocking:
+            logger.error("CONFIG", problem.message, level="important")
+            sys.exit(1)
+        logger.warn("CONFIG", problem.message, level="important")
+
+    for path in (config.local_vault, config.cloud_vault, config.sync_baseline, config.logs_dir):
+        if path:
+            os.makedirs(path, exist_ok=True)
+
+    logger.info("START", f"local={config.local_vault} cloud={config.cloud_vault}", level="important")
+    engine = SyncEngine(config, logger)
+    TrayApp(config, logger, engine).run()
+
+
+def cmd_run(args):
+    _run(args.config)
+
+
+def cmd_setup(args):
+    from .setup_wizard import main as run_wizard
+    run_wizard()
+
+
+def cmd_start(args):
+    """Launches the console-less tray (existing config, no re-mapping
+    folders) without blocking this terminal — unlike `run`, which stays
+    attached. If oiiaw is already running, the launched process's own
+    duplicate-instance check handles that."""
+    from . import autostart
+    if not autostart.start_now():
+        print("oiiaw-tray.exe를 찾을 수 없습니다. pip install이 정상적으로 끝났는지 확인하세요.")
+        sys.exit(1)
+    print("oiiaw를 시작했습니다.")
+
+
+def main_tray():
+    """Entry point for the console-less `oiiaw-tray` GUI script — what
+    Task Scheduler launches at logon, and what the setup wizard's
+    "start now" offer runs. It has no console to report to, so if setup
+    was never completed (no config.yaml yet), fall into the setup wizard
+    instead of crashing silently."""
+    config_path = default_config_path()
+    if not os.path.isfile(config_path):
+        from .setup_wizard import main as run_wizard
+        run_wizard()
+        return
+    _run(config_path)
+
+
+def cmd_status(args):
+    config = Config.load(args.config)
+    problems = config.validate()
+    if not problems:
+        print("config: ok")
+    for problem in problems:
+        tag = "blocking" if problem.blocking else "warning"
+        print(f"config [{tag}]: {problem.message}")
+
+    status = StatusReporter.read(config.logs_dir)
+    if StatusReporter.is_fresh(status):
+        uptime = int(time.time() - status["started_at"])
+        print(
+            f"daemon: running (pid {status['pid']}, uptime {uptime}s, "
+            f"state={status['state']}, pending={status['pending']}, parked={status.get('parked', 0)})"
+        )
+        last = status.get("last_event")
+        if last:
+            print(f"  last event: {last['type']} {last['path']} ({int(time.time() - last['time'])}s ago)")
+        print(f"  this session: {status['conflict_count']} conflicts, {status['error_count']} errors")
+    else:
+        print("daemon: not running (or not responding)")
+
+    for name, path in (("local_vault", config.local_vault), ("cloud_vault", config.cloud_vault), ("sync_baseline", config.sync_baseline)):
+        count = sum(len(files) for _, _, files in os.walk(path)) if path and os.path.isdir(path) else 0
+        print(f"{name}: {count} files ({path or 'not set'})")
+
+
+def main():
+    parser = argparse.ArgumentParser(prog="oiiaw", description="Obsidian <-> iCloud sync bridge for Windows")
+    parser.add_argument("-c", "--config", default=default_config_path(), help="path to config YAML (default: %(default)s)")
+    sub = parser.add_subparsers(dest="command", required=True)
+    sub.add_parser("run", help="start the sync daemon (blocks this terminal)").set_defaults(func=cmd_run)
+    sub.add_parser("start", help="start the tray in the background, using the existing config").set_defaults(func=cmd_start)
+    sub.add_parser("status", help="check config and vault file counts").set_defaults(func=cmd_status)
+    sub.add_parser("setup", help="run the setup wizard (pick folders, register autostart)").set_defaults(func=cmd_setup)
+
+    args = parser.parse_args()
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

oiiaw-0.1.0/oiiaw/autostart.py

@@ -0,0 +1,46 @@
+"""
+Registers oiiaw to start at Windows logon via Task Scheduler. Targets the
+`oiiaw-tray` GUI entry point (Windows-subsystem exe, no console window) —
+not the `oiiaw` console script — since this runs unattended on every login.
+"""
+
+import sys
+import subprocess
+from pathlib import Path
+
+TASK_NAME = "oiiaw"
+
+
+def _locate_tray_exe() -> str | None:
+    python_dir = Path(sys.executable).parent
+    for candidate in (python_dir / "oiiaw-tray.exe", python_dir / "Scripts" / "oiiaw-tray.exe"):
+        if candidate.is_file():
+            return str(candidate)
+    return None
+
+
+def register() -> tuple[bool, str]:
+    exe = _locate_tray_exe()
+    if not exe:
+        return False, "oiiaw-tray.exe를 찾을 수 없습니다 — pip install이 정상적으로 끝났는지 확인해주세요."
+    result = subprocess.run(
+        ["schtasks", "/create", "/tn", TASK_NAME, "/tr", f'"{exe}"', "/sc", "onlogon", "/rl", "limited", "/f"],
+        capture_output=True, text=True,
+    )
+    if result.returncode != 0:
+        reason = (result.stderr or result.stdout or "알 수 없는 오류").strip()
+        return False, (
+            f"자동 시작 등록에 실패했습니다: {reason}\n"
+            "일부 PC에서는 관리자 권한이 필요할 수 있어요 — 마법사를 관리자 권한으로 "
+            "다시 실행해보세요. (동기화 자체는 계속 쓸 수 있고, 나중에 `oiiaw run`으로 "
+            "직접 실행하면 됩니다.)"
+        )
+    return True, "Windows 시작 시 자동으로 실행되도록 등록했습니다."
+
+
+def start_now() -> bool:
+    exe = _locate_tray_exe()
+    if not exe:
+        return False
+    subprocess.Popen([exe])
+    return True

oiiaw-0.1.0/oiiaw/cloud_status.py

@@ -0,0 +1,261 @@
+"""
+Ground-truth check for whether a Windows cloud-sync placeholder (iCloud,
+OneDrive, etc.) actually has its bytes on disk right now, via the Cloud
+Filter API (CldApi.dll / CfGetPlaceholderInfo) — not by inferring from
+GetFileAttributesW bits.
+
+Struct layout and enum values below are taken verbatim from Microsoft Learn
+(cfapi.h): CF_PLACEHOLDER_STANDARD_INFO, CF_PLACEHOLDER_INFO_CLASS,
+CF_PIN_STATE. Verified against real files in the user's iCloud vault, not
+just written from memory — see tests/test_cloud_status.py.
+"""
+
+import ctypes
+import asyncio
+import multiprocessing
+import os
+import platform
+from dataclasses import dataclass
+from enum import Enum
+
+FILE_READ_ATTRIBUTES = 0x0080
+FILE_SHARE_READ_WRITE_DELETE = 0x1 | 0x2 | 0x4
+OPEN_EXISTING = 3
+FILE_FLAG_BACKUP_SEMANTICS = 0x02000000
+FILE_FLAG_OPEN_REPARSE_POINT = 0x00200000
+INVALID_HANDLE_VALUE = ctypes.c_void_p(-1).value
+
+CF_PLACEHOLDER_INFO_STANDARD = 1
+
+
+class PinState(Enum):
+    UNSPECIFIED = 0
+    PINNED = 1
+    UNPINNED = 2
+    EXCLUDED = 3
+    INHERIT = 4
+
+
+class _CF_PLACEHOLDER_STANDARD_INFO(ctypes.Structure):
+    _fields_ = [
+        ("OnDiskDataSize", ctypes.c_int64),
+        ("ValidatedDataSize", ctypes.c_int64),
+        ("ModifiedDataSize", ctypes.c_int64),
+        ("PropertiesSize", ctypes.c_int64),
+        ("PinState", ctypes.c_int32),
+        ("InSyncState", ctypes.c_int32),
+        ("FileId", ctypes.c_int64),
+        ("SyncRootFileId", ctypes.c_int64),
+        ("FileIdentityLength", ctypes.c_uint32),
+    ]
+
+
+@dataclass(frozen=True)
+class PlaceholderInfo:
+    on_disk_bytes: int
+    validated_bytes: int
+    pin_state: PinState
+    in_sync: bool
+
+
+class CloudFilterUnavailable(Exception):
+    """Raised when the Cloud Filter API isn't usable on this system at all."""
+
+
+class CloudProbeTimeout(TimeoutError):
+    """The isolated Windows cloud-status probe stopped responding."""
+
+
+class CloudProbeError(RuntimeError):
+    """The isolated probe exited or returned an unexpected failure."""
+
+
+def _load_cldapi():
+    if platform.system() != "Windows":
+        raise CloudFilterUnavailable("Cloud Filter API is Windows-only")
+    k32 = ctypes.WinDLL("kernel32", use_last_error=True)
+    k32.CreateFileW.argtypes = [
+        ctypes.c_wchar_p,
+        ctypes.c_uint32,
+        ctypes.c_uint32,
+        ctypes.c_void_p,
+        ctypes.c_uint32,
+        ctypes.c_uint32,
+        ctypes.c_void_p,
+    ]
+    k32.CreateFileW.restype = ctypes.c_void_p
+    k32.CloseHandle.argtypes = [ctypes.c_void_p]
+
+    cldapi = ctypes.WinDLL("cldapi", use_last_error=True)
+    cldapi.CfGetPlaceholderInfo.argtypes = [
+        ctypes.c_void_p,
+        ctypes.c_int,
+        ctypes.c_void_p,
+        ctypes.c_uint32,
+        ctypes.POINTER(ctypes.c_uint32),
+    ]
+    cldapi.CfGetPlaceholderInfo.restype = ctypes.c_long
+    return k32, cldapi
+
+
+class CloudFilter:
+    def __init__(self):
+        self._available = True
+        try:
+            self._k32, self._cldapi = _load_cldapi()
+        except (CloudFilterUnavailable, AttributeError, OSError):
+            self._available = False
+
+    def get_placeholder_info(self, path: str) -> PlaceholderInfo | None:
+        """
+        Returns None if `path` isn't tracked as a cloud-filter placeholder at
+        all (plain local file, or the API call otherwise failed) — callers
+        should treat that as "content is available".
+        """
+        if not self._available:
+            return None
+
+        handle = self._k32.CreateFileW(
+            str(path),
+            FILE_READ_ATTRIBUTES,
+            FILE_SHARE_READ_WRITE_DELETE,
+            None,
+            OPEN_EXISTING,
+            FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT,
+            None,
+        )
+        if handle is None or handle == INVALID_HANDLE_VALUE:
+            return None
+
+        try:
+            # CF_PLACEHOLDER_STANDARD_INFO ends with a variable-length
+            # FileIdentity blob — sizeof() on the fixed struct alone is too
+            # small and the call fails with ERROR_MORE_DATA. Over-allocate
+            # and reinterpret just the fixed prefix we care about.
+            buf = ctypes.create_string_buffer(4096)
+            returned = ctypes.c_uint32(0)
+            hr = self._cldapi.CfGetPlaceholderInfo(
+                handle,
+                CF_PLACEHOLDER_INFO_STANDARD,
+                buf,
+                ctypes.sizeof(buf),
+                ctypes.byref(returned),
+            )
+            if hr != 0:
+                return None  # not a placeholder, or the call failed — caller falls back to "available"
+            info = ctypes.cast(buf, ctypes.POINTER(_CF_PLACEHOLDER_STANDARD_INFO)).contents
+            return PlaceholderInfo(
+                on_disk_bytes=info.OnDiskDataSize,
+                validated_bytes=info.ValidatedDataSize,
+                pin_state=PinState(info.PinState),
+                in_sync=bool(info.InSyncState),
+            )
+        finally:
+            self._k32.CloseHandle(handle)
+
+    def is_content_available(self, path: str) -> bool:
+        """True if every byte of the file is already on disk — safe to read
+        or copy right now without triggering a network fetch."""
+        info = self.get_placeholder_info(path)
+        if info is None:
+            return True
+        try:
+            full_size = os.path.getsize(path)
+        except OSError:
+            return False
+        return info.on_disk_bytes >= full_size
+
+
+def _probe_worker(connection):
+    """Runs unsafe provider calls outside the sync process's event loop.
+
+    A cloud provider can block inside CreateFileW/CfGetPlaceholderInfo without
+    raising. The parent can terminate this process; it cannot safely terminate
+    a stuck Python thread.
+    """
+    cloud_filter = CloudFilter()
+    try:
+        while True:
+            try:
+                path = connection.recv()
+            except EOFError:
+                return
+            if path is None:
+                return
+            try:
+                connection.send(("ok", cloud_filter.is_content_available(path)))
+            except BaseException as exc:
+                connection.send(("error", f"{type(exc).__name__}: {exc}"))
+    finally:
+        connection.close()
+
+
+class CloudProbe:
+    """Async facade over one disposable cloud-status helper process."""
+
+    def __init__(self, timeout_seconds: float = 5.0, context=None):
+        self.timeout_seconds = timeout_seconds
+        self._context = context or multiprocessing.get_context("spawn")
+        self._connection = None
+        self._process = None
+        self._lock: asyncio.Lock | None = None
+
+    def _ensure_worker(self):
+        if self._process is not None and self._process.is_alive():
+            return
+        self._discard_worker()
+        parent, child = self._context.Pipe()
+        process = self._context.Process(
+            target=_probe_worker,
+            args=(child,),
+            name="oiiaw-cloud-probe",
+            daemon=True,
+        )
+        process.start()
+        child.close()
+        self._connection = parent
+        self._process = process
+
+    def _discard_worker(self):
+        connection, process = self._connection, self._process
+        self._connection = None
+        self._process = None
+        if connection is not None:
+            connection.close()
+        if process is not None:
+            if process.is_alive():
+                process.terminate()
+            process.join(timeout=0.2)
+            if process.is_alive():
+                process.kill()
+                process.join(timeout=0.2)
+
+    async def is_content_available(self, path: str) -> bool:
+        if self._lock is None:
+            self._lock = asyncio.Lock()
+        async with self._lock:
+            self._ensure_worker()
+            try:
+                self._connection.send(str(path))
+            except (BrokenPipeError, EOFError, OSError) as exc:
+                self._discard_worker()
+                raise CloudProbeError(f"could not contact cloud probe: {exc}") from exc
+
+            # Pipe polling has its own hard timeout and wakes immediately on a
+            # response. Running only that bounded wait in a thread avoids both
+            # event-loop blocking and a 50 ms polling tax for every vault file.
+            ready = await asyncio.to_thread(self._connection.poll, self.timeout_seconds)
+            if not ready:
+                self._discard_worker()
+                raise CloudProbeTimeout(f"cloud probe exceeded {self.timeout_seconds:.1f}s")
+            try:
+                kind, payload = self._connection.recv()
+            except (EOFError, OSError) as exc:
+                self._discard_worker()
+                raise CloudProbeError(f"cloud probe exited: {exc}") from exc
+            if kind == "ok":
+                return bool(payload)
+            raise CloudProbeError(str(payload))
+
+    def close(self):
+        self._discard_worker()

oiiaw-0.1.0/oiiaw/config.py

@@ -0,0 +1,61 @@
+import os
+import glob
+import yaml
+from dataclasses import dataclass
+
+
+def discover_icloud_vault() -> str | None:
+    """Finds the Obsidian iCloud container under the user's iCloudDrive folder."""
+    home = os.path.expanduser("~")
+    candidates = glob.glob(os.path.join(home, "iCloudDrive", "iCloud~md~obsidian"))
+    return candidates[0] if candidates else None
+
+
+@dataclass(frozen=True)
+class ConfigProblem:
+    message: str
+    blocking: bool  # True: can't start; False: worth a warning but startable
+
+
+class Config:
+    def __init__(self, data: dict):
+        paths = data.get("paths", {})
+        self.local_vault = paths.get("local_vault", "")
+        self.cloud_vault = paths.get("cloud_vault") or discover_icloud_vault() or ""
+        self.sync_baseline = paths.get("sync_baseline", "")
+        self.logs_dir = paths.get("logs_dir", "")
+
+        sync = data.get("sync", {})
+        self.stability_window = sync.get("stability_window", 3)
+        self.stabilize_wait = sync.get("stabilize_wait", 8)
+        self.cooldown_seconds = sync.get("cooldown_seconds", 3)
+        self.cloud_probe_timeout = sync.get("cloud_probe_timeout", 5)
+        self.big_file_threshold = sync.get("big_file_threshold", 102400)
+        self.big_file_cooldown = sync.get("big_file_cooldown", 30)
+        logging_cfg = data.get("logging", {})
+        self.console_level = logging_cfg.get("console_level", "normal")
+        self.log_retention = logging_cfg.get("log_retention", 10)
+
+        ignore = data.get("ignore", {})
+        self.ignored_dirs = {d.lower() for d in ignore.get("dirs", [])}
+        self.ignored_files = {f.lower() for f in ignore.get("files", [])}
+        self.ignore_patterns = ignore.get("patterns", [])
+
+    @classmethod
+    def load(cls, path: str) -> "Config":
+        with open(path, "r", encoding="utf-8") as f:
+            data = yaml.safe_load(f) or {}
+        return cls(data)
+
+    def validate(self) -> list[ConfigProblem]:
+        problems = []
+        if not self.local_vault:
+            problems.append(ConfigProblem("paths.local_vault is not set", blocking=True))
+        if not self.cloud_vault:
+            problems.append(ConfigProblem("paths.cloud_vault is not set and could not be auto-discovered", blocking=True))
+        if self.local_vault and self.cloud_vault and os.path.normcase(self.local_vault) == os.path.normcase(self.cloud_vault):
+            problems.append(ConfigProblem("local_vault and cloud_vault must not be the same folder", blocking=True))
+        for name, value in (("local_vault", self.local_vault), ("cloud_vault", self.cloud_vault)):
+            if value and not os.path.isdir(value):
+                problems.append(ConfigProblem(f"{name} does not exist yet: {value}", blocking=False))
+        return problems