chore(remote): миграция Gitea-URL на сабдомен git.

Gitea переехал с path-prefix (xn--90adajar8af4h.xn--p1ai/git/) на
выделенный сабдомен (git.xn--90adajar8af4h.xn--p1ai). Старый URL теперь
отдаёт чужое приложение и для git мёртв.

- package.json: publish.url (канал авто-апдейта) -> новый хост
- scripts/release.ps1, upload-release-assets.ps1: $giteaHost (API + release URL)
- README, CHANGELOG, RELEASING.md, CLAUDE.md: ссылки на репозиторий/релизы

Прим.: уже установленные копии (<=0.5.8) запекли старый URL в бинарник —
их авто-апдейт нужно мигрировать отдельно (bridge-теги), правкой конфига
это ретроактивно не лечится.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

CHANGELOG.md

@@ -6,6 +6,281 @@
 
 ## [Unreleased]
 
+## [0.5.8] — 2026-05-22
+
+Автономный QA-проход: проверил все элементы, нашёл и починил несколько
+коварных багов, добавил тесты на новые модули.
+
+### Fixed
+
+- **Heatmap / streak / достижения теперь обновляются после markDone.**
+  Был регресс из Sprint C (#9 — отделение history от broadcastState):
+  `markDone` мутирует Exercise in-place → state.exercises ref не
+  меняется → Dashboard useEffect с дептой `[exercises]` не fire'ил → 
+  history не перетягивалась. Heatmap стоял пока пользователь не
+  добавит/удалит упражнение. Сейчас новый event `evtHistoryChanged`
+  шлётся из main после `markDone/snooze/skip/markChallengeDone/
+  clearHistory/import`, Dashboard на него подписан.
+- **Rapid double-click больше не пишет в историю дважды.** В Match
+  Summary при быстром тыке ✓ дважды один и тот же challenge мог
+  записаться 2 раза → лишние +N reps в стрик. То же для кнопки
+  «Готово» в ExerciseCard. ref-based дедуп.
+- **Native save/open dialogs локализованы.** Раньше title `«Сохранить
+  резервную копию»` показывался даже в EN-локали.
+- **Default exerciseName в challenge editor — пустой** (было
+  «Приседания» — выглядело как недопереведённый русский в EN UI).
+
+### Added
+
+- 18 новых тестов: `achievements.test.ts` (10), расширения
+  `history.test.ts` (8) — match-challenges через snapshot, deleted
+  exercise survival, race-edge cases.
+
+## [0.5.7] — 2026-05-22
+
+Сквозное ревью UX: пройдено 12 сценариев глазами пользователя, найдено
+13 проблем (3 настоящих бага P0 + 4 UX-просадки P1 + 6 мелочей P2),
+все починены.
+
+### Fixed (P0 — функциональные баги)
+
+- **Match-челленджи теперь пишутся в историю.** Раньше клик ✓ в окне
+  Match Summary обновлял только локальный `Set<challengeId>` — челленджи
+  не доходили до store, и стрик / today_done / достижения игнорировали
+  игровые тренировки (самую главную фишку приложения). Сейчас IPC
+  `markChallengeDone` пишет entry с `source='match'`,
+  `exerciseId='challenge:<id>'`, `actualReps`, `reps` (snapshot).
+- **Tray-пауза синхронизирована с Dashboard.** Раньше «Пауза напоминаний»
+  из tray использовала scheduler-local `paused` boolean, который не
+  отражался в `settings.globalEnabled` — Dashboard показывал «running»
+  с тикающим таймером, хотя fires не приходили. Сейчас единый
+  source of truth — `settings.globalEnabled`. `setPaused/isPaused`
+  удалены, IPC `pauseAll/resumeAll` переписаны на updateSettings.
+- **WhatsNew покажется обновляющимся пользователям.** В v0.5.6 логика
+  была: `lastSeenVersion === undefined` → silent save (не показывать).
+  Это означало что **никто** из текущих пользователей при апгрейде с
+  v0.5.5 не увидит описание новых фич. Сейчас: если есть Exercise
+  с `lastDoneAt` — пользователь существующий, показываем заметки
+  текущей версии. Иначе (новичок) — silent.
+
+### Fixed (P1 — UX просадки)
+
+- **Удаление упражнения теперь спрашивает подтверждение.** Раньше
+  один клик в menu «Удалить» сразу удалял. Сейчас iOS-style ConfirmModal
+  с destructive-кнопкой.
+- **Daily goal закрыт — больше не «25 часов 13 минут».** Когда дневная
+  цель достигнута, ExerciseCard показывает «Цель закрыта · 100/100»
+  с success-зелёным цветом, а не запутанный обратный отсчёт до завтра.
+- **Авто-пауза на ВКС видна в Dashboard.** Раньше fires пропускались
+  молча — пользователь не понимал почему через 12 мин ничего не пришло.
+  Сейчас info-баннер «Не дёргаем — ты на встрече» с указанием закрыть
+  Zoom/Teams/etc.
+- **Native `window.confirm()` → iOS-style ConfirmModal** в restore-операции.
+  Раньше всплывал серый системный диалог.
+
+### Fixed (P2 — полировка)
+
+- **Achievement unlock celebration.** Когда впервые открылся новый
+  badge — pulse + accent-glow анимация 2.8 сек. Список celebrated
+  хранится в localStorage, при следующем заходе анимации нет.
+- **Match Summary close confirm.** При закрытии окна с незакрытыми
+  челленджами спрашиваем подтверждение с указанием остатка.
+- **TTS задержка 800мс.** Дикторский голос даёт пользователю шанс
+  decrement'нуть stepper — иначе TTS произносил планируемые reps в тот
+  момент когда юзер уже изменил цифру.
+- **Tracking badge точность.** Раньше зелёный показывался даже при
+  `queued` launch option. Сейчас 3 состояния: `live` (success, всё
+  работает), `setup` (warning «закрой Steam и снова открой» если launch
+  option ещё не применён), `off` (muted, не подключено).
+- **HistoryEntry хранит snapshot `reps`+`name`+`source`.** Heatmap и
+  achievements больше не теряют данные после удаления упражнения.
+- **Adaptive-badge на ExerciseCard.** Маленькая Brain-иконка показывает,
+  что упражнение в адаптивном режиме — пользователь понимает почему
+  Next не строго равен intervalMinutes.
+
+### Added
+
+- `src/renderer/src/components/ui/ConfirmModal.tsx` — переиспользуемый
+  iOS-style confirm с focus-trap'ом через Modal.
+- IPC `markChallengeDone(challengeId, reps)` — handler в main, метод в
+  preload (раньше канал был в IPC enum, handler не зарегистрирован).
+- IPC `getMeetingActive` + event `evtMeetingChanged` — meeting-detect
+  broadcast'ит при переходе on/off.
+- Helper `repsDoneTodayForExercise(history, exercise)` —
+  per-exercise daily count для UI индикатора goal.
+
+## [0.5.6] — 2026-05-22
+
+Большой релиз с 7 новыми фичами + экран «Что нового», который покажется
+автоматически после установки этой версии.
+
+### Added
+
+- **Категории напоминаний** (#7) — кроме упражнений теперь
+  hydration / eye-rest (20-20-20) / posture. Каждая со своим CTA в
+  окне напоминания. В SAMPLE добавлены примеры.
+- **TTS-голосовые подсказки** (#8) — диктор произносит название
+  упражнения и количество. Opt-in в Settings → «Голосовая подсказка».
+  Web Speech API: подбор голоса под язык (ru-RU / en-US).
+- **Достижения** (#10) — milestones по total reps (100/500/1000/5k/10k),
+  streaks (3/7/14/30/100 дней), first_day, today_quad. На Dashboard
+  карточка с unlocked + 2 ближайших по прогрессу. Прогресс-бар до
+  следующего достижения.
+- **Дневная цель** (#12) — soft cap reps/день в exercise editor.
+  Когда total reps за сегодня (с actualReps) ≥ dailyGoal → scheduler
+  переносит fire на завтра. История = source of truth.
+- **Авто-пауза на ВКС** (#5) — сканирует процессы tasklist'ом раз в
+  30с: Zoom/Teams (старый+new)/Discord/Webex/Slack/Skype/Meet/Whereby/
+  GoToMeeting. Если запущен — fires не выполняются.
+- **Адаптивный шедулер** (#2) — opt-in флаг в exercise editor.
+  Heuristic-модель строит hour-of-day success rate по 30 дням истории
+  (≥10 событий обязательно). При попадании fire в «плохой» час
+  (success ≤ 30%) сдвигает на ближайший «хороший» (≥50%), в пределах
+  4 часов.
+- **Export / Import** (#9) — Settings → Data. Native save/open
+  dialogs Electron. JSON-snapshot всего persisted-state (включая
+  историю). Import = replace, не merge — UI просит подтверждение.
+- **Экран «Что нового»** — модалка с заметками релизов. Показывается
+  автоматически когда `lastSeenVersion` ≠ текущей версии (после
+  обновления). Доступна также из Settings → «О приложении».
+  Реестр заметок в `src/shared/release-notes.ts`, версионируется
+  per-app.
+
+### Changed
+
+- Settings.lastSeenVersion (optional) — отслеживает что пользователь
+  видел.
+- IPC.getAppVersion → app.getVersion() для renderer.
+- DEFAULT_SETTINGS: добавлены `voicePromptsEnabled: false`,
+  `meetingAutoPause: true`.
+- Exercise type расширен: `category?`, `dailyGoal?`, `adaptive?`.
+  Все обратно совместимые (optional).
+
+### Performance
+
+- Scheduler запрашивает history только если есть упражнения с
+  dailyGoal или adaptive — иначе экономит IPC.
+
+## [0.5.5] — 2026-05-22
+
+Большой sweep по ревизии: 4 спринта правок (≈14 пунктов), все 135 тестов
+зелёные. Главное — UI больше не залипает при retry'ях I/O, GSI порт не
+зависает в TIME_WAIT после выхода, sandbox включён, шрифты self-hosted.
+
+### Security
+
+- **`sandbox: true`** на обоих BrowserWindow. Preload использует только
+  contextBridge + ipcRenderer (sandbox-safe), никаких Node-built-ins.
+  OS-уровневый sandbox изолирует renderer на уровне процессов — даже
+  RCE в зависимости рендерера не получит Node-доступа через preload.
+- **CSP ужесточён.** Убраны `https://fonts.googleapis.com` и
+  `https://fonts.gstatic.com` origins (шрифты теперь self-hosted),
+  добавлены `connect-src 'self'`, `base-uri 'self'`,
+  `frame-ancestors 'none'`.
+
+### Added
+
+- **Self-hosted шрифты.** Plus Jakarta Sans, Bricolage Grotesque,
+  JetBrains Mono подключены через `@fontsource/*` пакеты — в bundle
+  лежат локально, без интернета шрифты работают, CSP без внешних
+  origins. +22 .woff/.woff2 (~500KB) в installer.
+- **`src/main/logger.ts`** — структурный logger с уровнями
+  (debug/info/warn/error) и ротацией. Пишет в
+  `%APPDATA%/Exercise Reminder/logs/latest.log` (≤1MB) и дублирует
+  в console. При 1MB ротируется в `prev.log`. `LAUDE_DEBUG=1`
+  включает debug-уровень. Подключён в hot paths: store, updater,
+  GSI server, registry, dota2 provider — особенно полезно для
+  диагностики «челленджи не срабатывают» (видно token verify,
+  POST_GAME detection, фильтрацию challenges).
+- `<html lang>` синхронизируется с `settings.language` через
+  ThemeProvider — screen readers корректно произносят язык.
+- `dev:simulateMatchEnd` channel вынесен в IPC enum
+  (`IPC.devSimulateMatchEnd`).
+- `test:coverage` npm script.
+
+### Changed
+
+- **`broadcastState` больше не шлёт `history`** через IPC. Раньше
+  каждый markDone/snooze отправлял весь state включая до 10k
+  history-записей (~500KB JSON) к каждому BrowserWindow. Теперь
+  `AppState` (renderer-facing) без `history`, а `PersistedState`
+  (internal) с историей. Renderer и так дёргал `getHistory()`
+  отдельно, поведение не изменилось — только perf.
+- **`lib/icon.tsx`**: `import * as Lucide` (wildcard, ~500KB всех
+  1500+ иконок в bundle) → explicit named imports + ICON_MAP.
+  В bundle только 18 ICON_CHOICES.
+- **ChallengeEditor**: multiplier клампится в UI до [0.5, 1000]
+  (совпадает с validate.ts). Раньше save с 9999 молча отклонялся
+  IPC-валидатором.
+
+### Fixed
+
+- **`atomicWrite` spin-loop → async setTimeout.** Раньше при retry
+  на EBUSY/EPERM (антивирус, OneDrive) main process замораживался
+  на 50/200/800ms × до 3 итераций ≈ секунда залипания UI. Сейчас
+  async sleep — event-loop живёт. Аналогичный фикс в
+  `games/steam-launch-options.ts`. Сохранён sync-вариант для
+  `flushNow` в `before-quit` (там event-loop уже не работает).
+- **`before-quit` дожидается `stopGamesRegistry`** через
+  `e.preventDefault()` + `app.exit(0)`. Раньше GSI HTTP server
+  не успевал `closeAllConnections` до exit, и следующий запуск
+  получал EADDRINUSE на порту 4701 (TIME_WAIT) — GSI молча не
+  работал.
+- **IPC `getState` не мутирует кэш.** Раньше `state.settings.startWithWindows`
+  перезаписывалось напрямую, разъезжаясь с persisted-disk-значением
+  до следующего mutation. Сейчас возвращается поверхностная копия.
+
+## [0.5.4] — 2026-05-19
+
+Обновление приложения теперь по-настоящему фоновое + почти моментальный
+рестарт в новую версию.
+
+### Changed
+
+- **Скачивание апдейта — фоновое.** Раньше клик «Скачать» блокировал
+  кнопку (`busy=true`) до конца download'а (минуты на медленной сети).
+  Теперь IPC `updaterDownload` — fire-and-forget, прогресс приходит
+  через события. Пользователь сразу может уйти на Dashboard и
+  продолжать упражнения, апдейт качается в фоне.
+- **«Рестарт» — почти моментальный.** `quitAndInstall(true, true)`:
+  isSilent=true — NSIS без UI установщика (~1-2 сек вместо ~5-10),
+  isForceRunAfter=true — гарантия что приложение откроется после.
+  Раньше показывался диалог установщика с прогрессом, теперь —
+  только мгновение между закрытием и появлением новой версии.
+- Подсказка на экране скачивания: «можно закрыть это окно, продолжится
+  в фоне». На downloaded-экране: «нажми Рестарт — приложение
+  моментально откроется в новой версии».
+
+## [0.5.3] — 2026-05-19
+
+Полировка кастомного тайтлбара и размера окна.
+
+### Added
+
+- **Maximize/Restore.** Средняя кнопка тайтлбара (иконка квадрата)
+  раньше была «спрятать в трей» — выглядела как нативная Windows
+  maximize и сбивала с толку. Теперь это настоящий toggle на
+  весь экран: иконка свапается `Square` ↔ `Copy` в зависимости
+  от состояния, aria-label локализован.
+- **Double-click по тайтлбару** тоже toggleMaximize — стандартный
+  Windows-жест.
+- **CLAUDE.md** в корне — контекст проекта для будущих сессий
+  Claude Code (стек, архитектура, команды, тех. долг).
+
+### Fixed
+
+- **Drag-зона тайтлбара.** Окно не двигалось, если хватать его
+  рядом с кнопками свернуть/закрыть. Класс `titlebar-nodrag` стоял
+  на обёртке кластера с `flex-1 basis-0`, поэтому пустое место
+  слева от иконок тоже было no-drag. Перенесли `no-drag` на сами
+  кнопки — теперь тащить можно отовсюду, кроме самих квадратиков.
+
+### Changed
+
+- **Минимальный размер окна** 900×600 → 1100×700. Гарантирует
+  срабатывание Tailwind `lg:` (4 hero-stat в один ряд, heatmap
+  и сетка упражнений помещаются без горизонтального скролла).
+
 ## [0.5.2] — 2026-05-19
 
 Большая внутренняя итерация: тройной независимый аудит (~220 находок),
@@ -171,8 +446,15 @@
 иконки), системный трей, автозапуск с Windows, native-уведомления,
 NSIS-инсталлятор, auto-update через electron-updater.
 
-[Unreleased]: https://xn--90adajar8af4h.xn--p1ai/git/AnRil/laude/compare/v0.5.1...HEAD
+[Unreleased]: https://git.xn--90adajar8af4h.xn--p1ai/AnRil/laude/compare/v0.5.8...HEAD
-[0.5.1]: https://xn--90adajar8af4h.xn--p1ai/git/AnRil/laude/releases/tag/v0.5.1
+[0.5.8]: https://git.xn--90adajar8af4h.xn--p1ai/AnRil/laude/releases/tag/v0.5.8
-[0.5.0]: https://xn--90adajar8af4h.xn--p1ai/git/AnRil/laude/releases/tag/v0.5.0
+[0.5.7]: https://git.xn--90adajar8af4h.xn--p1ai/AnRil/laude/releases/tag/v0.5.7
-[0.4.0]: https://xn--90adajar8af4h.xn--p1ai/git/AnRil/laude/releases/tag/v0.4.0
+[0.5.6]: https://git.xn--90adajar8af4h.xn--p1ai/AnRil/laude/releases/tag/v0.5.6
-[0.2.0]: https://xn--90adajar8af4h.xn--p1ai/git/AnRil/laude/releases/tag/v0.2.0
+[0.5.5]: https://git.xn--90adajar8af4h.xn--p1ai/AnRil/laude/releases/tag/v0.5.5
+[0.5.4]: https://git.xn--90adajar8af4h.xn--p1ai/AnRil/laude/releases/tag/v0.5.4
+[0.5.3]: https://git.xn--90adajar8af4h.xn--p1ai/AnRil/laude/releases/tag/v0.5.3
+[0.5.2]: https://git.xn--90adajar8af4h.xn--p1ai/AnRil/laude/releases/tag/v0.5.2
+[0.5.1]: https://git.xn--90adajar8af4h.xn--p1ai/AnRil/laude/releases/tag/v0.5.1
+[0.5.0]: https://git.xn--90adajar8af4h.xn--p1ai/AnRil/laude/releases/tag/v0.5.0
+[0.4.0]: https://git.xn--90adajar8af4h.xn--p1ai/AnRil/laude/releases/tag/v0.4.0
+[0.2.0]: https://git.xn--90adajar8af4h.xn--p1ai/AnRil/laude/releases/tag/v0.2.0

CLAUDE.md

@@ -0,0 +1,188 @@
+# CLAUDE.md
+
+Контекст проекта для Claude Code. Читается при старте каждой сессии.
+
+## TL;DR
+
+**Laude / Exercise Reminder** — Windows desktop приложение на Electron 33, которое напоминает делать упражнения и опционально парсит статистику матчей Dota 2 (через GSI) в количество повторений. Текущая версия — **0.5.8**. Один разработчик (AnRil), один remote — self-hosted Gitea.
+
+## Стек
+
+- **Runtime**: Electron 33 (main + preload + renderer)
+- **Build**: electron-vite 2 + Vite 5 + electron-builder 25 (NSIS, x64 only)
+- **UI**: React 18 + TypeScript 5 + Tailwind 3 + framer-motion + react-router (HashRouter) + zustand 5
+- **Auto-update**: electron-updater 6, generic provider, фиксированный канал
+- **Тесты**: Vitest 4 (203 теста, все зелёные)
+- **Lint/format**: ESLint 8 (flat-ish .eslintrc.cjs) + Prettier 3 + EditorConfig
+- **Иконки**: lucide-react (whitelisted lookup через `ICON_CHOICES`)
+- **Шрифты**: Plus Jakarta Sans, Bricolage Grotesque, JetBrains Mono (Google Fonts CDN)
+
+## Архитектура (важное)
+
+### Процессы
+- **main** (`src/main/`) — Node, scheduler, GSI HTTP-сервер, IPC, окна, tray, updater, persistence
+- **preload** (`src/preload/index.ts`) — contextBridge → `window.api`, dev-only методы вырезаны на проде (`import.meta.env.MODE !== 'production'`)
+- **renderer** (`src/renderer/src/`) — React, zustand-store, страницы Dashboard/Games/Settings/About, ReminderApp в отдельном окне
+
+### Persistence
+- Единственный JSON-файл: `%APPDATA%\Exercise Reminder\app-state.json`
+- **Атомарная запись**: tmp + rename + retry на EBUSY/EPERM (антивирус, OneDrive)
+- **Не теряет данные**: corrupt JSON → quarantine в `app-state.json.corrupt-<ts>`, не silent wipe
+- **Schema migrations**: `__schemaVersion` поле + `MIGRATIONS: Record<number, (s)=>s>` map в `src/main/store.ts`
+- **Debounced writes**: pendingWrite с `.unref()`
+
+### IPC
+- Типизированные каналы — `src/shared/ipc.ts`
+- **Validation layer** — `src/main/validate.ts` (hand-rolled, без zod):
+  - `intervalMinutes ∈ [1, 1440]`, `reps ∈ [1, 9999]`, `multiplier ∈ [0, 1000]`
+  - string cap 200 chars, enum-валидация для theme/lang/notify-mode/stat
+  - HH:MM regex для quietHours, dedup days
+  - Strip `id` из updateExercise/updateChallenge patch
+- **Error-boundary**: все хендлеры обёрнуты в `safeHandle`/`safeOn` (`src/main/ipc.ts`) — исключение логируется в `latest.log`, наружу уходит generic `ipc-failed` (не падаем молча, не утекают детали)
+- **Dev-only**: `dev:simulateMatchEnd` gated на `!app.isPackaged`
+
+### Отказоустойчивость main
+- **Глобальные хендлеры** в `src/main/index.ts`: `uncaughtException` (лог + `flushNow`) и `unhandledRejection` (лог) — процесс не исчезает молча
+- **tasklist timeout** 4s в `meeting-detect.ts` (зависший child не копится)
+- **Sync write на exit** через `Atomics.wait` (не busy-spin) в `store.ts`
+
+### Auto-update (КРИТИЧНО)
+- **Фиксированный URL канала**: `…/releases/download/update-channel/latest.yml` — никогда не меняется
+- **НЕ** `…/releases/download/v${version}/…` (старая схема ломалась: установленная копия видела только свой релиз)
+- Hourly silent auto-check (транзитные сетевые ошибки не показывают красный баннер; только ручной клик показывает ошибку)
+- Boot-check: 3 ретрая с backoff 30s/2m/5m
+- `lastCheckedAt` → UI «проверено N мин назад»
+- Релиз через `scripts/release.ps1` публикует одной командой в:
+  1. `vX.Y.Z` (постоянный архивный тег)
+  2. `update-channel` (rolling — клиенты проверяют отсюда)
+  3. Опциональные `-BridgeTags` для миграции старых пользователей
+
+### Безопасность
+- **GSI server** (`src/main/games/gsi-server.ts`): per-install token verify через `timingSafeEqual`, reject Origin/Sec-Fetch-Site (CSRF), 256KB body cap, require `application/json`, generic 400
+- **shell.openExternal allowlist**: только `http:`/`https:`/`mailto:` (`src/main/windows.ts`)
+- **will-navigate** блокирует non-file:// и non-dev URL
+- **Modal focus trap** + focus restore, aria-labelledby
+
+### Quiet hours
+- `isQuietAt(time, settings)` в `src/shared/types.ts`
+- Wrap-around (22:00 → 07:00) корректно — при wrap-active проверяется день *начала* окна
+- Тесты в `src/shared/quiet-hours.test.ts`
+
+### История / стрики
+- `src/renderer/src/lib/history.ts` — DST-safe через `shiftDays()` (calendar `setDate`, не ms-арифметика)
+- Cap 10k записей, trim oldest 10% на overflow
+- HistoryHeatmap: percentile-based bucketing (p25/p50/p85), а не flat ratio (защищает от outlier-дней)
+
+### i18n
+- Самописная микро-система: `src/renderer/src/i18n/dict.ts` (плоский словарь ~200 ключей × 2 языка)
+- Хук `useT()`, плюрализация CLDR rules для RU (one/few/many)
+- Интерполяция через split/join (не regex — защита от regex-инъекций в значениях var)
+- Tray menu тоже локализован (`TRAY_STRINGS` в `src/main/tray.ts`)
+
+## Команды
+
+```bash
+npm run dev              # electron-vite dev
+npm run typecheck        # tsc по node + web
+npm run test:run         # vitest один раз
+npm run lint             # eslint --max-warnings 0
+npm run format           # prettier --write
+npm run dist             # сборка + NSIS installer → release/
+
+# Релиз (всё в одном)
+npm run release -- -Bump patch
+# или -Bump minor / -Bump major / -Version 1.2.3
+# опционально: -BridgeTags v0.4.0,v0.4.1
+```
+
+## Скрипты релиза
+
+- `scripts/release.ps1` — bump → typecheck → test → build → tag → push → upload в Gitea (vX.Y.Z + update-channel + bridges)
+- `scripts/upload-release-assets.ps1` — curl.exe с retry/backoff (15s/45s/2m/5m × 4) на 504/TLS, проверяет уже-залилось через list assets перед ретраем
+- **PowerShell 5.1 gotchas**:
+  - Default reads CP1251 → файлы скриптов **ASCII-only**, без em-dash/кириллицы в коде
+  - `Set-Content -Encoding utf8` добавляет BOM → ломает PostCSS. Для UTF-8 без BOM использовать `[System.IO.File]::WriteAllText` + `new UTF8Encoding($false)`
+  - Никогда `-i` флаги (rebase -i, add -i) — нет interactive input
+
+## Gitea remote
+
+- URL: `https://git.xn--90adajar8af4h.xn--p1ai/AnRil/laude` (Punycode для `президент.рф`; Gitea переехал с `…/git/` на сабдомен `git.`)
+- User: `anril`
+- Auth: см. `~/.claude/projects/.../memory/gitea_remote.md`
+- **Actions выключены** (`has_actions: false`) — релизим через PowerShell, runners не настроены
+- `.gitea/workflows/` пустая (раньше там лежали yml → queued runs копились)
+
+## Файлы, которые часто правлю
+
+| Файл | Что |
+|---|---|
+| `package.json` | version, publish.url, scripts, deps |
+| `src/main/store.ts` | persistence, migrations, validation, atomic writes |
+| `src/main/ipc.ts` | IPC handlers с валидацией |
+| `src/main/scheduler.ts` | таймеры упражнений, powerMonitor |
+| `src/main/games/dota2.ts` + `gsi-server.ts` | GSI приём матчей |
+| `src/main/updater.ts` | auto-update logic, silent retries |
+| `src/shared/types.ts` | shared типы, дефолты, isQuietAt |
+| `src/shared/ipc.ts` | IPC channel types |
+| `src/renderer/src/i18n/dict.ts` | словари |
+| `src/renderer/src/pages/Dashboard.tsx` | главная |
+| `src/renderer/src/ReminderApp.tsx` | окно напоминания |
+
+## Тесты (203)
+
+```
+src/main/validate.test.ts                (68)
+src/renderer/src/lib/history.test.ts     (31)
+src/renderer/src/i18n/i18n.test.ts       (15)
+src/renderer/src/lib/format.test.ts      (14)
+src/main/games/vdf.test.ts               (11)
+src/main/store.test.ts                   (10)  ← main: миграции/карантин/cap
+src/renderer/src/lib/achievements.test.ts (10)
+src/shared/release-notes.test.ts          (9)
+src/main/scheduler.test.ts                (8)  ← main: gating-логика
+src/main/meeting-detect.test.ts           (7)  ← main: детект ВКС + кэш/timeout
+src/shared/quiet-hours.test.ts            (7)
+src/main/adaptive.test.ts                 (6)
+src/shared/types.test.ts                  (4)
+src/renderer/src/lib/icon-choices.test.ts (3)
+```
+
+Покрываются: IPC-валидация, persistence (миграции/карантин/cap), scheduler-gating
+(тихие часы/ВКС/daily-goal), детект ВКС (мок child_process), helpers, история/стрики
+(DST), тихие часы (wrap+filter), VDF-парсер Steam, достижения, i18n с плюрализацией,
+дефолты.
+
+Паттерн для main-тестов: `vi.mock('electron'|'./store'|'node:child_process')` +
+`vi.resetModules()` + dynamic import (сброс module-level состояния между тестами).
+
+## Технический долг (не для пользователя)
+
+- `sandbox: true` на BrowserWindow — нужен smoke-тест preload в sandbox-режиме
+- Self-host Google Fonts (сейчас внешняя CSP-зависимость)
+- ReminderApp race: первое напоминание может прийти без озвучки до загрузки settings
+- Мажорные апдейты (React 18→19, Electron 33→42, Tailwind 3→4) — каждый ломающий, отдельная итерация
+- Code-signing NSIS — ~$300/год, уберёт SmartScreen warning
+- Скриншоты в README (есть TODO в самом README)
+
+## Стиль кода
+
+- Prettier: semi:false, singleQuote, trailingComma:none, printWidth:80
+- ESLint: eslint:recommended + ts + react + react-hooks (без style rules — это Prettier)
+- TypeScript strict, никакого `any` в новом коде
+- Комментарии на русском там, где объясняют **почему**, не **что**
+- Коммиты на русском, формат `тип(scope): кратко` (feat/fix/docs/refactor/test/chore)
+- Co-Authored-By футер в коммитах от Claude
+
+## Управление контекстом
+
+- **Ужимать контекст при достижении 250k токенов** — вызывать `/compact` (или эквивалент) когда суммарный контекст подходит к 250 000 токенов. Не дожидаться authentic переполнения и автоматического сжатия от рантайма — сделать это контролируемо, чтобы важный контекст (открытые правки, недокоммиченные решения, текущая ветка задачи) попал в summary, а не выпал.
+
+## Чего НЕ делать
+
+- Не пушить в `update-channel` руками — только через `release.ps1`
+- Не добавлять `.gitea/workflows/*.yml` — has_actions выключен, runs зависнут
+- Не использовать regex в i18n-интерполяции — только split/join
+- Не silent wipe corrupt JSON — quarantine с timestamp
+- Не возвращать ms-арифметику в history.ts — DST сломается
+- Не убирать validation layer из IPC — compromised renderer может засунуть NaN/негативы
+- Не амендить коммиты без явной просьбы пользователя

LICENSE

@@ -0,0 +1,49 @@
+Exercise Reminder (Laude)
+Proprietary Software License
+
+Copyright (c) 2026 AnRil. All rights reserved.
+
+1. Definitions
+   "Software" means the Exercise Reminder (Laude) application, including its
+   source code, binaries, installers, assets, and documentation, in any form.
+   "Author" means the copyright holder named above.
+
+2. Grant
+   The Author grants you a personal, non-exclusive, non-transferable, revocable
+   license to install and use the Software on devices you own or control, for
+   your own personal, non-commercial purposes.
+
+3. Restrictions
+   Except as expressly permitted by this license or by mandatory applicable
+   law, you may NOT, without the Author's prior written permission:
+     (a) copy, publish, distribute, sublicense, sell, rent, or lease the
+         Software or any part of it;
+     (b) modify, adapt, translate, or create derivative works of the Software;
+     (c) reverse engineer, decompile, or disassemble the Software, or otherwise
+         attempt to derive its source code, except to the extent this
+         restriction is prohibited by applicable law;
+     (d) remove or alter any copyright, trademark, or other proprietary notices.
+
+4. Ownership
+   The Software is licensed, not sold. The Author retains all right, title, and
+   interest in and to the Software, including all intellectual property rights.
+   No rights are granted other than those expressly set out in this license.
+
+5. No Warranty
+   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 NON-INFRINGEMENT.
+
+6. Limitation of Liability
+   IN NO EVENT SHALL THE AUTHOR 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.
+
+7. Termination
+   This license terminates automatically if you breach any of its terms. Upon
+   termination you must stop using the Software and delete all copies in your
+   possession.
+
+For permissions beyond the scope of this license, contact the Author through
+the project repository.

README.md

@@ -2,8 +2,8 @@
 
 Windows desktop приложение, которое напоминает делать упражнения во время работы за компьютером. Опционально подключается к Dota 2 и после каждого матча превращает статистику (смерти, убийства, ассисты) в количество повторений.
 
-[![release](https://img.shields.io/badge/release-v0.5.2-orange)](https://xn--90adajar8af4h.xn--p1ai/git/AnRil/laude/releases/latest)
+[![release](https://img.shields.io/badge/release-v0.5.8-orange)](https://git.xn--90adajar8af4h.xn--p1ai/AnRil/laude/releases/latest)
-[![tests](https://img.shields.io/badge/tests-51%20passing-green)]()
+[![tests](https://img.shields.io/badge/tests-203%20passing-green)]()
 [![platform](https://img.shields.io/badge/platform-Windows%2010%2F11-blue)]()
 
 ## Что внутри
@@ -34,7 +34,7 @@ Windows SmartScreen может предупредить «не доверено
 ## Разработка
 
 ```bash
-git clone https://xn--90adajar8af4h.xn--p1ai/git/AnRil/laude.git
+git clone https://git.xn--90adajar8af4h.xn--p1ai/AnRil/laude.git
 cd laude
 npm install
 npm run dev
@@ -66,21 +66,32 @@ npm run release -- -Bump patch    # bump версии + tag + push + upload в G
 ## Тесты
 
 ```
-src/shared/types.test.ts                (4)
+src/main/validate.test.ts               (68)
-src/shared/quiet-hours.test.ts          (5)
+src/renderer/src/lib/history.test.ts     (31)
-src/renderer/src/lib/format.test.ts     (8)
+src/renderer/src/i18n/i18n.test.ts       (15)
-src/renderer/src/lib/history.test.ts   (13)
+src/renderer/src/lib/format.test.ts      (14)
-src/main/games/vdf.test.ts             (11)
+src/main/games/vdf.test.ts               (11)
-src/renderer/src/i18n/i18n.test.ts     (10)
+src/main/store.test.ts                   (10)
-─────────────────────────────────────────
+src/renderer/src/lib/achievements.test.ts (10)
-                                  51 ✓
+src/shared/release-notes.test.ts          (9)
+src/main/scheduler.test.ts                (8)
+src/main/meeting-detect.test.ts           (7)
+src/shared/quiet-hours.test.ts            (7)
+src/main/adaptive.test.ts                 (6)
+src/shared/types.test.ts                  (4)
+src/renderer/src/lib/icon-choices.test.ts (3)
+──────────────────────────────────────────
+                                   203 ✓
 ```
 
-Покрытие: чистые helpers (форматирование, история/стрики, тихие часы, парсер VDF для Steam-конфигов), i18n с плюрализацией для RU/EN, дефолты shared-типов.
+Покрытие: IPC-валидация, persistence (миграции, карантин битого JSON, history cap), scheduler-гейтинг (тихие часы, ВКС-пауза, daily-goal), детект ВКС, история/стрики (DST), тихие часы (wrap), парсер VDF для Steam-конфигов, достижения, i18n с плюрализацией RU/EN, дефолты shared-типов.
 
 ## Лицензия
 
-Пока не указана. По умолчанию все права защищены. Если хочешь форк/использование — открой issue.
+Проприетарная — все права защищены. Личное некоммерческое использование
+разрешено; копирование, распространение, модификация и реверс-инжиниринг — без
+письменного разрешения автора. Полный текст — в файле [LICENSE](LICENSE). По
+вопросам использования за рамками лицензии открой issue в репозитории.
 
 ## Stack
 

RELEASING.md

@@ -40,7 +40,7 @@ latest.yml                                  # манифест: версия +
 В `package.json` → `build.publish.url`:
 
 ```
-https://xn--90adajar8af4h.xn--p1ai/git/AnRil/laude/releases/download/update-channel
+https://git.xn--90adajar8af4h.xn--p1ai/AnRil/laude/releases/download/update-channel
 ```
 
 Этот URL **никогда не меняется**. Все версии (и сегодняшние, и будущие)

package-lock.json

@@ -1,13 +1,16 @@
 {
   "name": "laude",
-  "version": "0.5.1",
+  "version": "0.5.4",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "laude",
-      "version": "0.5.1",
+      "version": "0.5.4",
       "dependencies": {
+        "@fontsource/bricolage-grotesque": "^5.2.10",
+        "@fontsource/jetbrains-mono": "^5.2.8",
+        "@fontsource/plus-jakarta-sans": "^5.2.8",
         "electron-updater": "^6.8.3",
         "framer-motion": "^11.11.17",
         "lucide-react": "^0.460.0",
@@ -1264,6 +1267,33 @@
         "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
       }
     },
+    "node_modules/@fontsource/bricolage-grotesque": {
+      "version": "5.2.10",
+      "resolved": "https://registry.npmjs.org/@fontsource/bricolage-grotesque/-/bricolage-grotesque-5.2.10.tgz",
+      "integrity": "sha512-V2xS+1P7C8IrSypXLUx/bLtX/LsTlYtV2k2CsU+S/0t8qepZ2hvKSlyJIx7Ub/iY8Bbnj+IjAuUF9nvFz+BbIg==",
+      "license": "OFL-1.1",
+      "funding": {
+        "url": "https://github.com/sponsors/ayuhito"
+      }
+    },
+    "node_modules/@fontsource/jetbrains-mono": {
+      "version": "5.2.8",
+      "resolved": "https://registry.npmjs.org/@fontsource/jetbrains-mono/-/jetbrains-mono-5.2.8.tgz",
+      "integrity": "sha512-6w8/SG4kqvIMu7xd7wt6x3idn1Qux3p9N62s6G3rfldOUYHpWcc2FKrqf+Vo44jRvqWj2oAtTHrZXEP23oSKwQ==",
+      "license": "OFL-1.1",
+      "funding": {
+        "url": "https://github.com/sponsors/ayuhito"
+      }
+    },
+    "node_modules/@fontsource/plus-jakarta-sans": {
+      "version": "5.2.8",
+      "resolved": "https://registry.npmjs.org/@fontsource/plus-jakarta-sans/-/plus-jakarta-sans-5.2.8.tgz",
+      "integrity": "sha512-P5qE49fqdeD+7DXH1KBxmMPlB17LTz1zvBhFH0tFzfnYTKVJVyb0pR6plh0ZGXxcB+Oayb54FZZw3V42/DawTw==",
+      "license": "OFL-1.1",
+      "funding": {
+        "url": "https://github.com/sponsors/ayuhito"
+      }
+    },
     "node_modules/@gar/promisify": {
       "version": "1.1.3",
       "resolved": "https://registry.npmjs.org/@gar/promisify/-/promisify-1.1.3.tgz",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "laude",
-  "version": "0.5.2",
+  "version": "0.5.8",
   "description": "Exercise reminder — Windows desktop app",
   "main": "out/main/index.js",
   "author": "AnRil",
@@ -14,6 +14,7 @@
     "typecheck": "npm run typecheck:node && npm run typecheck:web",
     "test": "vitest",
     "test:run": "vitest run",
+    "test:coverage": "vitest run --coverage",
     "format": "prettier --write \"src/**/*.{ts,tsx,css}\" \"*.{json,md}\" \".github/**/*.yml\"",
     "format:check": "prettier --check \"src/**/*.{ts,tsx,css}\" \"*.{json,md}\"",
     "lint": "eslint src --ext .ts,.tsx --max-warnings 0",
@@ -24,6 +25,9 @@
     "gen:icons": "powershell -ExecutionPolicy Bypass -File scripts/gen-icons.ps1"
   },
   "dependencies": {
+    "@fontsource/bricolage-grotesque": "^5.2.10",
+    "@fontsource/jetbrains-mono": "^5.2.8",
+    "@fontsource/plus-jakarta-sans": "^5.2.8",
     "electron-updater": "^6.8.3",
     "framer-motion": "^11.11.17",
     "lucide-react": "^0.460.0",
@@ -97,7 +101,7 @@
     },
     "publish": {
       "provider": "generic",
-      "url": "https://xn--90adajar8af4h.xn--p1ai/git/AnRil/laude/releases/download/update-channel",
+      "url": "https://git.xn--90adajar8af4h.xn--p1ai/AnRil/laude/releases/download/update-channel",
       "channel": "latest"
     }
   }

scripts/release.ps1

@@ -51,7 +51,7 @@ $ErrorActionPreference = 'Stop'
 
 $repoOwner = 'AnRil'
 $repoName  = 'laude'
-$giteaHost = 'xn--90adajar8af4h.xn--p1ai/git'
+$giteaHost = 'git.xn--90adajar8af4h.xn--p1ai'
 $channelTag = 'update-channel'
 
 # --- Pre-flight ----------------------------------------------------------

scripts/upload-release-assets.ps1

@@ -32,7 +32,7 @@ $ErrorActionPreference = 'Stop'
 
 $repoOwner = 'AnRil'
 $repoName  = 'laude'
-$giteaHost = 'xn--90adajar8af4h.xn--p1ai/git'
+$giteaHost = 'git.xn--90adajar8af4h.xn--p1ai'
 $apiBase   = "https://$giteaHost/api/v1"
 
 if (-not $env:GITEA_TOKEN) {

src/main/adaptive.test.ts

@@ -0,0 +1,126 @@
+import { describe, expect, it } from 'vitest'
+import type { Exercise, HistoryEntry } from '@shared/types'
+import { adjustNextFireAt } from './adaptive'
+
+const ex: Exercise = {
+  id: 'e1',
+  name: 'Pushups',
+  reps: 10,
+  icon: 'Dumbbell',
+  intervalMinutes: 30,
+  enabled: true,
+  nextFireAt: 0,
+  adaptive: true
+}
+
+function entryAt(year: number, month: number, day: number, hour: number, action: 'done' | 'skip' | 'snooze'): HistoryEntry {
+  return {
+    exerciseId: 'e1',
+    ts: new Date(year, month - 1, day, hour).getTime(),
+    action
+  }
+}
+
+/** Помощник: построить N entries в указанный hour-of-day за последние 30 дней. */
+function buildAtHour(hour: number, doneCount: number, skipCount: number): HistoryEntry[] {
+  const now = new Date()
+  const out: HistoryEntry[] = []
+  for (let i = 0; i < doneCount; i++) {
+    const d = new Date(now)
+    d.setDate(d.getDate() - i - 1)
+    d.setHours(hour, 0, 0, 0)
+    out.push({ exerciseId: 'e1', ts: d.getTime(), action: 'done' })
+  }
+  for (let i = 0; i < skipCount; i++) {
+    const d = new Date(now)
+    d.setDate(d.getDate() - i - 1)
+    d.setHours(hour, 0, 0, 0)
+    out.push({ exerciseId: 'e1', ts: d.getTime(), action: 'skip' })
+  }
+  return out
+}
+
+describe('adjustNextFireAt', () => {
+  it('returns candidate unchanged when history is too small (<10 events)', () => {
+    const candidate = new Date(2026, 4, 22, 14, 30).getTime()
+    const result = adjustNextFireAt(ex, candidate, [
+      entryAt(2026, 4, 21, 14, 'done'),
+      entryAt(2026, 4, 20, 14, 'done')
+    ])
+    expect(result).toBe(candidate)
+  })
+
+  it('returns candidate unchanged when candidate hour is not bad', () => {
+    // Час 14 — хороший (10 done, 0 skip = 100% success). Не сдвигаем.
+    const history = buildAtHour(14, 10, 0)
+    const candidate = new Date()
+    candidate.setHours(14, 30, 0, 0)
+    expect(adjustNextFireAt(ex, candidate.getTime(), history)).toBe(
+      candidate.getTime()
+    )
+  })
+
+  it('shifts candidate from a bad hour to the nearest non-bad hour', () => {
+    // Час 9 — плохой (1 done, 9 skip = 10% success).
+    // Час 10 — нейтральный (no data) = good по нашему определению.
+    // Спецификация: шедулер выбирает первый non-bad час, neutral OK
+    // (пользователь ещё не показал, что этот час плохой).
+    const history = [
+      ...buildAtHour(9, 1, 9), // 10 событий, success 10%
+      ...buildAtHour(11, 10, 0) // 10 событий, success 100%
+    ]
+    const candidate = new Date()
+    candidate.setHours(9, 30, 0, 0)
+    const result = adjustNextFireAt(ex, candidate.getTime(), history)
+    const shifted = new Date(result)
+    // Час 10 ближайший non-bad (neutral).
+    expect(shifted.getHours()).toBe(10)
+    expect(shifted.getMinutes()).toBe(0)
+  })
+
+  it('does not shift beyond MAX_SHIFT_HOURS (4 hours)', () => {
+    // Час 9 — плохой. Все часы 10..23 без данных (neutral, не «good»
+    // по нашему определению isHourGood которое требует tota=0 OR rate>=0.5).
+    // Wait — isHourGood вернёт true если total===0 (neutral). Значит
+    // сдвиг произойдёт на 10:00. Это OK поведение — neutral час лучше
+    // плохого.
+    const history = buildAtHour(9, 1, 9)
+    const candidate = new Date()
+    candidate.setHours(9, 30, 0, 0)
+    const result = adjustNextFireAt(ex, candidate.getTime(), history)
+    // Сдвиг на 10:00 (первый neutral час).
+    expect(new Date(result).getHours()).toBe(10)
+  })
+
+  it('only counts entries for this exercise', () => {
+    // Истории много, но всё по другому упражнению — не trust'able.
+    const otherEx: HistoryEntry[] = []
+    for (let i = 0; i < 20; i++) {
+      const d = new Date()
+      d.setDate(d.getDate() - i - 1)
+      d.setHours(9, 0, 0, 0)
+      otherEx.push({ exerciseId: 'other', ts: d.getTime(), action: 'skip' })
+    }
+    const candidate = new Date()
+    candidate.setHours(9, 30, 0, 0)
+    expect(adjustNextFireAt(ex, candidate.getTime(), otherEx)).toBe(
+      candidate.getTime()
+    )
+  })
+
+  it('ignores entries older than 30 days', () => {
+    // 20 событий 60 дней назад → не учитываются (только 30-day window).
+    const oldHistory: HistoryEntry[] = []
+    for (let i = 0; i < 20; i++) {
+      const d = new Date()
+      d.setDate(d.getDate() - 60 - i)
+      d.setHours(9, 0, 0, 0)
+      oldHistory.push({ exerciseId: 'e1', ts: d.getTime(), action: 'skip' })
+    }
+    const candidate = new Date()
+    candidate.setHours(9, 30, 0, 0)
+    expect(adjustNextFireAt(ex, candidate.getTime(), oldHistory)).toBe(
+      candidate.getTime()
+    )
+  })
+})

src/main/adaptive.ts

@@ -0,0 +1,94 @@
+/**
+ * Адаптивный шедулер v1: смотрит на исторические success/skip-паттерны
+ * по часам дня и сдвигает следующий fire на ближайший «хороший» час.
+ *
+ * Без ML, чистая heuristic. Идея: каждому часу 0..23 присваиваем
+ * success-rate = done / (done + skip + snooze). Если интервал шедулера
+ * приходится на «плохой» час (success ≤ 30%), сдвигаем fire вперёд на
+ * ближайший «хороший» (≥ 50% success или не имеющий данных = neutral).
+ *
+ * Окно учитываемой истории: 30 дней. Требует минимум 10 событий по
+ * упражнению, иначе истории слишком мало для статистики — возвращаем
+ * candidate без изменений.
+ *
+ * Этот модуль НЕ обязателен для работы шедулера; вызывается опционально
+ * когда у упражнения `adaptive: true`.
+ */
+import type { Exercise, HistoryEntry } from '@shared/types'
+
+const LOOKBACK_MS = 30 * 24 * 60 * 60 * 1000 // 30 дней
+const MIN_EVENTS_FOR_TRUST = 10
+const BAD_HOUR_THRESHOLD = 0.3
+const GOOD_HOUR_THRESHOLD = 0.5
+/** Максимальный сдвиг — чтобы не утащить fire на 6 часов вперёд. */
+const MAX_SHIFT_HOURS = 4
+
+type HourStats = {
+  done: number
+  skipped: number
+  total: number
+}
+
+function buildHourStats(
+  exerciseId: string,
+  history: HistoryEntry[]
+): HourStats[] {
+  const cutoff = Date.now() - LOOKBACK_MS
+  const stats: HourStats[] = Array.from({ length: 24 }, () => ({
+    done: 0,
+    skipped: 0,
+    total: 0
+  }))
+  for (const e of history) {
+    if (e.exerciseId !== exerciseId) continue
+    if (e.ts < cutoff) continue
+    const h = new Date(e.ts).getHours()
+    stats[h].total++
+    if (e.action === 'done') stats[h].done++
+    else stats[h].skipped++ // skip + snooze оба считаются «не done»
+  }
+  return stats
+}
+
+function isHourGood(s: HourStats): boolean {
+  if (s.total === 0) return true // нет данных — нейтрально, ОК
+  return s.done / s.total >= GOOD_HOUR_THRESHOLD
+}
+
+function isHourBad(s: HourStats): boolean {
+  if (s.total < 3) return false // данных мало, не делаем выводы
+  return s.done / s.total <= BAD_HOUR_THRESHOLD
+}
+
+/**
+ * Возвращает скорректированный timestamp следующего fire. Если candidate
+ * попадает на «плохой» час и есть «хороший» час в пределах MAX_SHIFT_HOURS,
+ * сдвигаем на начало этого хорошего часа. Иначе возвращаем candidate
+ * как есть.
+ */
+export function adjustNextFireAt(
+  exercise: Exercise,
+  candidateTs: number,
+  history: HistoryEntry[]
+): number {
+  // Сначала собираем total — если истории мало, не двигаем.
+  const stats = buildHourStats(exercise.id, history)
+  const total = stats.reduce((s, h) => s + h.total, 0)
+  if (total < MIN_EVENTS_FOR_TRUST) return candidateTs
+
+  const candDate = new Date(candidateTs)
+  const candHour = candDate.getHours()
+  if (!isHourBad(stats[candHour])) return candidateTs
+
+  // Ищем ближайший «хороший» час в будущем (внутри MAX_SHIFT_HOURS).
+  for (let shift = 1; shift <= MAX_SHIFT_HOURS; shift++) {
+    const h = (candHour + shift) % 24
+    if (isHourGood(stats[h])) {
+      const target = new Date(candDate)
+      target.setHours(candHour + shift, 0, 0, 0)
+      return target.getTime()
+    }
+  }
+  // Не нашли — оставляем как есть.
+  return candidateTs
+}

src/main/games/dota2.ts

@@ -18,6 +18,7 @@ import {
   isSteamRunning
 } from './steam-launch-options'
 import type { GameId, GameStatus, LaunchOptionStatus } from '@shared/types'
+import { log } from '../logger'
 
 const APP_ID = '570'
 const INSTALL_DIR = 'dota 2 beta'
@@ -198,6 +199,8 @@ export class Dota2Provider implements GameProvider {
     this.latest = undefined
   }
 
+  private rejectedTokenLogged = false
+
   private handle(g: DotaGsi): void {
     // Verify the per-install token. Dota always sends auth.token; anything
     // without it (or with the wrong one) is some other process on localhost
@@ -207,6 +210,15 @@ export class Dota2Provider implements GameProvider {
       typeof incoming !== 'string' ||
       !safeEqualStrings(incoming, this.token)
     ) {
+      // Логируем только ОДИН раз за процесс — Dota шлёт payload каждые
+      // ~100ms во время матча, иначе zass'мём latest.log.
+      if (!this.rejectedTokenLogged) {
+        this.rejectedTokenLogged = true
+        log.warn(
+          '[dota2] GSI payload with invalid/missing token rejected. ' +
+            'Если приложение переустанавливалось — заново подключи Dota 2 в Games.'
+        )
+      }
       return
     }
 
@@ -235,8 +247,12 @@ export class Dota2Provider implements GameProvider {
     if (prev && prev !== state && state === 'DOTA_GAMERULES_STATE_POST_GAME') {
       // De-dupe: Dota can fire POST_GAME repeatedly while the scoreboard is open.
       const now = Date.now()
-      if (now - this.lastMatchEndAt < 30_000) return
+      if (now - this.lastMatchEndAt < 30_000) {
+        log.debug('[dota2] suppressed duplicate POST_GAME within 30s window')
+        return
+      }
       this.lastMatchEndAt = now
+      log.info('[dota2] POST_GAME detected, emitting match_end event')
 
       const p = this.latest?.player ?? {}
       const m = this.latest?.map ?? {}

src/main/games/gsi-server.ts

@@ -4,6 +4,7 @@ import {
   type Server,
   type ServerResponse
 } from 'node:http'
+import { log } from '../logger'
 
 export type GsiHandler = (
   payload: unknown,
@@ -87,7 +88,7 @@ async function onRequest(
     payload = text.length > 0 ? JSON.parse(text) : {}
   } catch (err) {
     // Log the real reason locally; do not echo it to the client.
-    console.warn('[gsi] bad request:', err instanceof Error ? err.message : err)
+    log.warn('[gsi] bad request', err instanceof Error ? err.message : err)
     res.statusCode = 400
     res.end()
     return
@@ -99,7 +100,7 @@ async function onRequest(
     res.setHeader('Content-Type', 'text/plain')
     res.end('ok')
   } catch (err) {
-    console.error('[gsi] handler threw:', err)
+    log.error('[gsi] handler threw', err)
     res.statusCode = 500
     res.end()
   }

src/main/games/registry.ts

@@ -13,6 +13,7 @@ import type {
 import { STAT_LABELS } from '@shared/types'
 import { getChallenges, getGamesEnabled } from '../store'
 import { fireMatchSummary } from '../notifications'
+import { log } from '../logger'
 
 const providers: Record<GameId, GameProvider> = {
   dota2: new Dota2Provider()
@@ -25,14 +26,23 @@ async function onMatchEnd(
   payload: MatchEndPayload
 ): Promise<void> {
   const provider = providers[gameId]
-  const challenges = getChallenges().filter(
+  const allChallenges = getChallenges().filter((c) => c.gameId === gameId)
-    (c) => c.gameId === gameId && c.enabled
+  const enabledChallenges = allChallenges.filter((c) => c.enabled)
+  log.info(
+    `[games] match_end gameId=${gameId} stats=${JSON.stringify(
+      payload.stats
+    )} challenges=${enabledChallenges.length}/${allChallenges.length} (enabled/total)`
   )
   const results: ChallengeResult[] = []
-  for (const ch of challenges) {
+  for (const ch of enabledChallenges) {
     const statValue = payload.stats[ch.stat] ?? 0
     const reps = Math.round(statValue * ch.multiplier)
-    if (reps <= 0) continue
+    if (reps <= 0) {
+      log.debug(
+        `[games] skip challenge "${ch.name}": ${ch.stat}=${statValue} × ${ch.multiplier} = ${reps}`
+      )
+      continue
+    }
     results.push({
       challengeId: ch.id,
       name: ch.name,
@@ -44,7 +54,21 @@ async function onMatchEnd(
       stat: ch.stat
     })
   }
-  if (results.length === 0) return
+  if (results.length === 0) {
+    log.warn(
+      `[games] match_end produced no reps (no enabled challenges matched stats). ` +
+        `Enabled challenges: ${enabledChallenges.length}, stats keys: ${Object.keys(
+          payload.stats
+        ).join(',')}`
+    )
+    return
+  }
+  log.info(
+    `[games] firing match summary: ${results.length} challenges, total reps ${results.reduce(
+      (s, r) => s + r.reps,
+      0
+    )}`
+  )
 
   const summary: MatchSummary = {
     gameId,
@@ -61,8 +85,9 @@ export async function startGamesRegistry(): Promise<void> {
   running = true
   try {
     await startGsiServer()
+    log.info('[games] GSI server started on port 4701')
   } catch (err) {
-    console.error('GSI server failed to start:', err)
+    log.error('[games] GSI server failed to start', err)
     return
   }
 
@@ -79,7 +104,7 @@ export async function startGamesRegistry(): Promise<void> {
     try {
       await provider.reconcile?.()
     } catch (err) {
-      console.error('reconcile failed for', id, err)
+      log.error(`[games] reconcile failed for ${id}`, err)
     }
     if (!enabled[id]) continue
     await provider.start((e) => {

src/main/games/steam-launch-options.ts

@@ -123,20 +123,19 @@ function writeBackup(path: string): void {
   }
 }
 
-function atomicWrite(path: string, contents: string): void {
+async function atomicWrite(path: string, contents: string): Promise<void> {
   // Write to temp then rename (atomic on Windows for same directory). Retry a
   // few times on transient EBUSY/EPERM (AV scanners and OneDrive sometimes
   // hold a handle briefly during a Steam config rewrite).
+  //
+  // Раньше тут был busy-loop sleep — Steam-конфиги пишутся редко, но из main
+  // process, и при попадании на занятый файл (Steam ещё держит handle) морозили
+  // весь UI на 250мс. Заменили на async setTimeout-sleep.
   const tmp = path + '.exr.tmp'
   const delays = [0, 50, 200]
   let lastErr: unknown
   for (const delay of delays) {
-    if (delay > 0) {
+    if (delay > 0) await new Promise<void>((r) => setTimeout(r, delay))
-      const until = Date.now() + delay
-      while (Date.now() < until) {
-        /* spin */
-      }
-    }
     try {
       writeFileSync(tmp, contents, 'utf-8')
       renameSync(tmp, path)
@@ -148,11 +147,11 @@ function atomicWrite(path: string, contents: string): void {
   throw lastErr
 }
 
-function modifyLaunchOptions(
+async function modifyLaunchOptions(
   configPath: string,
   appId: string,
   fn: (current: string) => string | null
-): boolean {
+): Promise<boolean> {
   let raw: string
   try {
     raw = readFileSync(configPath, 'utf-8')
@@ -188,7 +187,7 @@ function modifyLaunchOptions(
 
   writeBackup(configPath)
   try {
-    atomicWrite(configPath, stringifyVdf(parsed))
+    await atomicWrite(configPath, stringifyVdf(parsed))
   } catch {
     return false
   }
@@ -225,7 +224,7 @@ async function applyOptionToAllConfigs(
 ): Promise<void> {
   const paths = await getLocalConfigPaths()
   for (const p of paths) {
-    modifyLaunchOptions(p, appId, (current) => {
+    await modifyLaunchOptions(p, appId, (current) => {
       if (current.includes(option)) return current
       return current.length > 0 ? `${current} ${option}` : option
     })
@@ -238,7 +237,7 @@ async function removeOptionFromAllConfigs(
 ): Promise<void> {
   const paths = await getLocalConfigPaths()
   for (const p of paths) {
-    modifyLaunchOptions(p, appId, (current) => {
+    await modifyLaunchOptions(p, appId, (current) => {
       if (!current.includes(option)) return current
       return current
         .split(/\s+/)

src/main/index.ts

@@ -13,9 +13,26 @@ import { broadcastState } from './state-actions'
 import { startGamesRegistry, stopGamesRegistry } from './games/registry'
 import { initUpdater, stopUpdater } from './updater'
 import { IPC } from '@shared/ipc'
+import { log } from './logger'
 
 const APP_ID = 'com.anril.exercise-reminder'
 
+// Глобальная сеть безопасности: без этих обработчиков необработанное
+// исключение/rejection в main-процессе валит приложение молча — пользователь
+// видит, что окно просто исчезло, а в логах пусто. Логируем всё в latest.log.
+// uncaughtException дополнительно флашит state, чтобы не потерять данные.
+process.on('uncaughtException', (err) => {
+  log.error('[fatal] uncaughtException', err)
+  try {
+    flushNow()
+  } catch {
+    // flush сам может бросить (диск/AV) — мы уже в аварийном пути, глушим.
+  }
+})
+process.on('unhandledRejection', (reason) => {
+  log.error('[fatal] unhandledRejection', reason)
+})
+
 // Must be set BEFORE app.whenReady() for Windows toasts to show
 // the correct app name / icon in Action Center.
 app.setAppUserModelId(APP_ID)
@@ -38,7 +55,7 @@ if (!gotLock) {
 
     startScheduler()
     startGamesRegistry().catch((err) =>
-      console.error('games registry failed:', err)
+      log.error('[index] games registry failed', err)
     )
     initUpdater()
 
@@ -73,11 +90,26 @@ if (!gotLock) {
     }
   })
 
-  app.on('before-quit', () => {
+  // Перехватываем первый before-quit, чтобы дождаться `stopGamesRegistry`
+  // (закрывает GSI HTTP server со всеми pending connections). Без этого
+  // следующий запуск получает EADDRINUSE на port 4701 (TIME_WAIT), и
+  // GSI молча не работает. После cleanup'а — реально quit.
+  let quitting = false
+  app.on('before-quit', (e) => {
+    if (quitting) return
+    e.preventDefault()
+    quitting = true
     stopScheduler()
     stopUpdater()
-    void stopGamesRegistry()
+    void (async () => {
-    flushNow()
+      try {
+        await stopGamesRegistry()
+      } catch (err) {
+        log.error('[index] stopGamesRegistry threw', err)
+      }
+      flushNow()
+      app.exit(0)
+    })()
   })
 
   app.on('activate', () => {

src/main/ipc.ts

@@ -4,8 +4,11 @@ import {
   systemPreferences,
   BrowserWindow,
   app,
+  dialog,
   shell
 } from 'electron'
+import type { IpcMainEvent, IpcMainInvokeEvent } from 'electron'
+import { readFileSync, writeFileSync } from 'node:fs'
 import { IPC } from '@shared/ipc'
 import type { Exercise, GameId, Settings } from '@shared/types'
 import {
@@ -14,8 +17,12 @@ import {
   clearHistory,
   deleteChallenge,
   deleteExercise,
+  exportState,
   getHistory,
   getState,
+  getStateForRenderer,
+  importState,
+  markChallengeDone,
   markDone,
   setGameEnabled,
   skip,
@@ -24,9 +31,9 @@ import {
   updateExercise,
   updateSettings
 } from './store'
-import { broadcastState } from './state-actions'
+import { broadcastHistoryChanged, broadcastState } from './state-actions'
 import { setAutostart, isAutostartEnabled } from './autostart'
-import { setPaused, forceCheck } from './scheduler'
+import { forceCheck } from './scheduler'
 import { hideReminderWindow, getMainWindow } from './windows'
 import { refreshMenu } from './tray'
 import {
@@ -43,6 +50,7 @@ import {
   getUpdaterStatus,
   quitAndInstall
 } from './updater'
+import { isMeetingActiveSync } from './meeting-detect'
 import {
   validateActualReps,
   validateChallengeInput,
@@ -53,15 +61,68 @@ import {
   validateSettingsPatch,
   validateSnoozeMinutes
 } from './validate'
+import { log } from './logger'
+
+/**
+ * Враппер вокруг `ipcMain.handle`: ловит любое исключение в обработчике,
+ * пишет его в лог и отдаёт renderer'у обобщённую ошибку. Без этого один
+ * упавший хендлер молча обрывает invoke (renderer висит на await) и в проде
+ * не остаётся следов. Generic-сообщение наружу — не утекают внутренние детали.
+ *
+ * Констрейнт `...args: never[]` делает любую сигнатуру хендлера присваиваемой
+ * (контравариантность параметров), поэтому типы на call-site сохраняются.
+ */
+function safeHandle<
+  F extends (event: IpcMainInvokeEvent, ...args: never[]) => unknown
+>(channel: string, fn: F): void {
+  ipcMain.handle(channel, async (event, ...args) => {
+    try {
+      const call = fn as unknown as (
+        e: IpcMainInvokeEvent,
+        ...a: unknown[]
+      ) => unknown
+      return await call(event, ...args)
+    } catch (err) {
+      log.error(`[ipc] ${channel} threw`, err)
+      throw new Error('ipc-failed')
+    }
+  })
+}
+
+/**
+ * Аналог для `ipcMain.on` (fire-and-forget). Ошибку логируем, но не
+ * пробрасываем — у sender'а нет канала для ответа.
+ */
+function safeOn<F extends (event: IpcMainEvent, ...args: never[]) => void>(
+  channel: string,
+  fn: F
+): void {
+  ipcMain.on(channel, (event, ...args) => {
+    try {
+      const call = fn as unknown as (
+        e: IpcMainEvent,
+        ...a: unknown[]
+      ) => void
+      call(event, ...args)
+    } catch (err) {
+      log.error(`[ipc] ${channel} (on) threw`, err)
+    }
+  })
+}
 
 export function registerIpc(): void {
-  ipcMain.handle(IPC.getState, () => {
+  safeHandle(IPC.getState, () => {
-    const state = getState()
+    // Без history (см. getStateForRenderer) и с актуальным значением
-    state.settings.startWithWindows = isAutostartEnabled()
+    // autostart из OS — мутацию делаем по копии, не по cache.
+    const state = getStateForRenderer()
+    state.settings = {
+      ...state.settings,
+      startWithWindows: isAutostartEnabled()
+    }
     return state
   })
 
-  ipcMain.handle(IPC.addExercise, (_e, input: unknown) => {
+  safeHandle(IPC.addExercise, (_e, input: unknown) => {
     const safe = validateExerciseInput(input)
     if (!safe) return null
     const ex = addExercise(safe)
@@ -69,7 +130,7 @@ export function registerIpc(): void {
     return ex
   })
 
-  ipcMain.handle(
+  safeHandle(
     IPC.updateExercise,
     (_e, idRaw: unknown, patchRaw: unknown) => {
       const id = validateId(idRaw)
@@ -81,7 +142,7 @@ export function registerIpc(): void {
     }
   )
 
-  ipcMain.handle(IPC.deleteExercise, (_e, idRaw: unknown) => {
+  safeHandle(IPC.deleteExercise, (_e, idRaw: unknown) => {
     const id = validateId(idRaw)
     if (!id) return false
     const ok = deleteExercise(id)
@@ -89,7 +150,7 @@ export function registerIpc(): void {
     return ok
   })
 
-  ipcMain.handle(
+  safeHandle(
     IPC.toggleExercise,
     (_e, idRaw: unknown, enabledRaw: unknown) => {
       const id = validateId(idRaw)
@@ -105,32 +166,35 @@ export function registerIpc(): void {
     }
   )
 
-  ipcMain.handle(IPC.markDone, (_e, idRaw: unknown, repsRaw?: unknown) => {
+  safeHandle(IPC.markDone, (_e, idRaw: unknown, repsRaw?: unknown) => {
     const id = validateId(idRaw)
     if (!id) return null
     const ex = markDone(id, validateActualReps(repsRaw))
     broadcastState()
+    broadcastHistoryChanged()
     return ex
   })
 
-  ipcMain.handle(IPC.snooze, (_e, idRaw: unknown, minRaw: unknown) => {
+  safeHandle(IPC.snooze, (_e, idRaw: unknown, minRaw: unknown) => {
     const id = validateId(idRaw)
     const minutes = validateSnoozeMinutes(minRaw)
     if (!id || minutes === null) return null
     const ex = snooze(id, minutes)
     broadcastState()
+    broadcastHistoryChanged()
     return ex
   })
 
-  ipcMain.handle(IPC.skip, (_e, idRaw: unknown) => {
+  safeHandle(IPC.skip, (_e, idRaw: unknown) => {
     const id = validateId(idRaw)
     if (!id) return null
     const ex = skip(id)
     broadcastState()
+    broadcastHistoryChanged()
     return ex
   })
 
-  ipcMain.handle(IPC.updateSettings, (_e, patchRaw: unknown) => {
+  safeHandle(IPC.updateSettings, (_e, patchRaw: unknown) => {
     const patch = validateSettingsPatch(patchRaw)
     if (!patch) return null
     if (patch.startWithWindows !== undefined) {
@@ -142,22 +206,27 @@ export function registerIpc(): void {
     }
     const settings = updateSettings(merged)
     broadcastState()
-    // Language change reflects in the tray menu next time it's opened.
+    // Tray-menu label «Пауза/Возобновить» зависит от globalEnabled — рефреш.
-    if (patch.language !== undefined) refreshMenu()
+    // А также language change.
+    if (patch.language !== undefined || patch.globalEnabled !== undefined) {
+      refreshMenu()
+    }
     return settings
   })
 
-  ipcMain.handle(IPC.pauseAll, () => {
+  safeHandle(IPC.pauseAll, () => {
-    setPaused(true)
+    updateSettings({ globalEnabled: false })
+    broadcastState()
     refreshMenu()
   })
-  ipcMain.handle(IPC.resumeAll, () => {
+  safeHandle(IPC.resumeAll, () => {
-    setPaused(false)
+    updateSettings({ globalEnabled: true })
+    broadcastState()
     forceCheck()
     refreshMenu()
   })
 
-  ipcMain.handle(IPC.getAccentColor, () => {
+  safeHandle(IPC.getAccentColor, () => {
     try {
       return '#' + systemPreferences.getAccentColor()
     } catch {
@@ -165,30 +234,45 @@ export function registerIpc(): void {
     }
   })
 
-  ipcMain.handle(IPC.getOsTheme, () =>
+  safeHandle(IPC.getOsTheme, () =>
     nativeTheme.shouldUseDarkColors ? 'dark' : 'light'
   )
 
-  ipcMain.handle(IPC.quit, () => app.quit())
+  safeHandle(IPC.getAppVersion, () => app.getVersion())
-  ipcMain.handle(IPC.reminderClose, () => hideReminderWindow())
 
-  ipcMain.on(IPC.minimizeMain, (event) => {
+  safeHandle(IPC.getMeetingActive, () => isMeetingActiveSync())
+
+  safeHandle(IPC.quit, () => app.quit())
+  safeHandle(IPC.reminderClose, () => hideReminderWindow())
+
+  safeOn(IPC.minimizeMain, (event) => {
     BrowserWindow.fromWebContents(event.sender)?.minimize()
   })
 
-  ipcMain.on(IPC.closeMain, () => {
+  safeOn(IPC.toggleMaximizeMain, (event) => {
+    const win = BrowserWindow.fromWebContents(event.sender)
+    if (!win) return
+    if (win.isMaximized()) win.unmaximize()
+    else win.maximize()
+  })
+
+  safeHandle(IPC.isMaximizedMain, (event) => {
+    return BrowserWindow.fromWebContents(event.sender)?.isMaximized() ?? false
+  })
+
+  safeOn(IPC.closeMain, () => {
     const main = getMainWindow()
     if (!main) return
     if (getState().settings.minimizeToTray) main.hide()
     else main.close()
   })
 
-  ipcMain.on(IPC.hideMain, () => getMainWindow()?.hide())
+  safeOn(IPC.hideMain, () => getMainWindow()?.hide())
 
   // Games
-  ipcMain.handle(IPC.gamesList, async () => listGamesStatus())
+  safeHandle(IPC.gamesList, async () => listGamesStatus())
 
-  ipcMain.handle(IPC.gameInstall, async (_e, id: GameId) => {
+  safeHandle(IPC.gameInstall, async (_e, id: GameId) => {
     const status = await installGame(id)
     setGameEnabled(id, true)
     await toggleGame(id, true)
@@ -198,7 +282,7 @@ export function registerIpc(): void {
     return status
   })
 
-  ipcMain.handle(IPC.gameUninstall, async (_e, id: GameId) => {
+  safeHandle(IPC.gameUninstall, async (_e, id: GameId) => {
     const status = await uninstallGame(id)
     setGameEnabled(id, false)
     const all = await listGamesStatus()
@@ -207,7 +291,7 @@ export function registerIpc(): void {
     return status
   })
 
-  ipcMain.handle(IPC.gameToggle, async (_e, id: GameId, enabled: boolean) => {
+  safeHandle(IPC.gameToggle, async (_e, id: GameId, enabled: boolean) => {
     setGameEnabled(id, enabled)
     await toggleGame(id, enabled)
     const all = await listGamesStatus()
@@ -215,20 +299,20 @@ export function registerIpc(): void {
     broadcastState()
   })
 
-  ipcMain.handle(IPC.gameOpenLaunchOptions, (_e, _id: GameId) => {
+  safeHandle(IPC.gameOpenLaunchOptions, (_e, _id: GameId) => {
     // Opens Steam's library; user manually adds launch options.
     shell.openExternal('steam://nav/games/details/570')
   })
 
   // Challenges
-  ipcMain.handle(IPC.addChallenge, (_e, input: unknown) => {
+  safeHandle(IPC.addChallenge, (_e, input: unknown) => {
     const safe = validateChallengeInput(input)
     if (!safe) return null
     const c = addChallenge(safe)
     broadcastState()
     return c
   })
-  ipcMain.handle(
+  safeHandle(
     IPC.updateChallenge,
     (_e, idRaw: unknown, patchRaw: unknown) => {
       const id = validateId(idRaw)
@@ -239,14 +323,14 @@ export function registerIpc(): void {
       return c
     }
   )
-  ipcMain.handle(IPC.deleteChallenge, (_e, idRaw: unknown) => {
+  safeHandle(IPC.deleteChallenge, (_e, idRaw: unknown) => {
     const id = validateId(idRaw)
     if (!id) return false
     const ok = deleteChallenge(id)
     broadcastState()
     return ok
   })
-  ipcMain.handle(
+  safeHandle(
     IPC.toggleChallenge,
     (_e, idRaw: unknown, enabledRaw: unknown) => {
       const id = validateId(idRaw)
@@ -257,14 +341,27 @@ export function registerIpc(): void {
     }
   )
 
-  ipcMain.handle(IPC.closeMatchSummary, () => hideReminderWindow())
+  safeHandle(IPC.closeMatchSummary, () => hideReminderWindow())
+
+  safeHandle(
+    IPC.markChallengeDone,
+    (_e, idRaw: unknown, repsRaw: unknown) => {
+      const id = validateId(idRaw)
+      const reps = validateActualReps(repsRaw)
+      if (!id || reps === undefined || reps <= 0) return false
+      markChallengeDone(id, reps)
+      broadcastState()
+      broadcastHistoryChanged()
+      return true
+    }
+  )
 
   // Dev helper: simulate a match end with given stats. NEVER registered in
   // packaged builds — a compromised renderer (XSS, malicious npm dep) could
   // otherwise fabricate arbitrary match-end events at will.
   if (!app.isPackaged) {
-    ipcMain.handle(
+    safeHandle(
-      'dev:simulateMatchEnd',
+      IPC.devSimulateMatchEnd,
       (_e, id: GameId, stats: Record<string, number>) => {
         simulateMatchEnd(id, stats)
       }
@@ -272,14 +369,77 @@ export function registerIpc(): void {
   }
 
   // Auto-updater
-  ipcMain.handle(IPC.updaterStatus, () => getUpdaterStatus())
+  safeHandle(IPC.updaterStatus, () => getUpdaterStatus())
-  ipcMain.handle(IPC.updaterCheck, () => checkForUpdates())
+  safeHandle(IPC.updaterCheck, () => checkForUpdates())
-  ipcMain.handle(IPC.updaterDownload, () => downloadUpdate())
+  // download/install — fire-and-forget. Прогресс и завершение приходят в
-  ipcMain.handle(IPC.updaterInstall, () => quitAndInstall())
+  // renderer через evtUpdaterStatus, ждать promise бессмысленно — renderer
+  // только зря держал бы `busy=true` весь download (минуты на медленной сети).
+  safeOn(IPC.updaterDownload, () => {
+    void downloadUpdate()
+  })
+  safeOn(IPC.updaterInstall, () => quitAndInstall())
 
   // History
-  ipcMain.handle(IPC.getHistory, (_e, sinceMs?: number) => getHistory(sinceMs))
+  safeHandle(IPC.getHistory, (_e, sinceMs?: number) => getHistory(sinceMs))
-  ipcMain.handle(IPC.clearHistory, (_e, beforeTs?: number) =>
+  safeHandle(IPC.clearHistory, (_e, beforeTs?: number) => {
-    clearHistory(beforeTs)
+    const removed = clearHistory(beforeTs)
-  )
+    if (removed > 0) broadcastHistoryChanged()
+    return removed
+  })
+
+  // Export / Import. Используем native save/open dialogs Electron'а —
+  // renderer не получает прямого доступа к ФС.
+  safeHandle(IPC.exportState, async (event) => {
+    const win = BrowserWindow.fromWebContents(event.sender) ?? undefined
+    const stamp = new Date()
+      .toISOString()
+      .replace(/[:T]/g, '-')
+      .slice(0, 16)
+    const defaultPath = `laude-backup-${stamp}.json`
+    // Native-диалоги OS читают локаль из системы. Title — единственная
+    // строка которую мы контролируем; локализуем по settings.language.
+    const lang = getState().settings.language ?? 'ru'
+    const result = await dialog.showSaveDialog(win!, {
+      title:
+        lang === 'en' ? 'Save backup' : 'Сохранить резервную копию',
+      defaultPath,
+      filters: [{ name: 'JSON', extensions: ['json'] }]
+    })
+    // Cancel — это не ошибка. Возвращаем canceled=true чтобы UI мог
+    // ничего не показывать (без error toast).
+    if (result.canceled || !result.filePath) {
+      return { ok: false, canceled: true, path: null }
+    }
+    try {
+      writeFileSync(result.filePath, exportState(), 'utf-8')
+      return { ok: true, canceled: false, path: result.filePath }
+    } catch (e) {
+      return { ok: false, canceled: false, path: null, error: String(e) }
+    }
+  })
+
+  safeHandle(IPC.importState, async (event) => {
+    const win = BrowserWindow.fromWebContents(event.sender) ?? undefined
+    const lang = getState().settings.language ?? 'ru'
+    const result = await dialog.showOpenDialog(win!, {
+      title:
+        lang === 'en' ? 'Restore from backup' : 'Восстановить из резервной копии',
+      properties: ['openFile'],
+      filters: [{ name: 'JSON', extensions: ['json'] }]
+    })
+    if (result.canceled || result.filePaths.length === 0) {
+      return { ok: false, canceled: true }
+    }
+    try {
+      const raw = readFileSync(result.filePaths[0], 'utf-8')
+      const ok = importState(raw)
+      if (ok) {
+        broadcastState()
+        broadcastHistoryChanged()
+      }
+      return { ok, canceled: false }
+    } catch (e) {
+      return { ok: false, canceled: false, error: String(e) }
+    }
+  })
 }

src/main/logger.ts

@@ -0,0 +1,125 @@
+/* eslint-disable no-console -- этот файл — единственное место где console.*
+   разрешён намеренно: дублирование лога в stderr для dev-режима. */
+/**
+ * Минимальный logger для main process.
+ *
+ * Пишет в файл `%APPDATA%/Exercise Reminder/logs/latest.log` + дублирует
+ * в stderr через console.* (чтобы dev-режим оставался удобным).
+ *
+ * Ротация: при достижении 1MB latest.log переименовывается в prev.log
+ * (предыдущий prev.log удаляется). Две сессии истории — этого достаточно
+ * для воспроизведения «случилось вчера, а сегодня перезапустил». Никакой
+ * remote-телеметрии: лог локальный, пользователь сам может вложить его в
+ * issue если что-то сломалось.
+ *
+ * Уровни:
+ *  - debug: подробный traceback, видим только если LAUDE_DEBUG=1
+ *  - info:  значимые события (startup, GSI matched, updater progress)
+ *  - warn:  recoverable issues (transient network, retry succeeded)
+ *  - error: что-то реально сломалось (atomic write fail, IPC validation)
+ */
+import { app } from 'electron'
+import {
+  appendFileSync,
+  existsSync,
+  mkdirSync,
+  renameSync,
+  statSync,
+  unlinkSync
+} from 'node:fs'
+import { join } from 'node:path'
+
+const ROTATE_AT_BYTES = 1 * 1024 * 1024 // 1 MB
+
+type Level = 'debug' | 'info' | 'warn' | 'error'
+
+let logDir = ''
+let logPath = ''
+let prevPath = ''
+
+function ensurePaths(): void {
+  if (logDir) return
+  try {
+    logDir = join(app.getPath('userData'), 'logs')
+    if (!existsSync(logDir)) mkdirSync(logDir, { recursive: true })
+    logPath = join(logDir, 'latest.log')
+    prevPath = join(logDir, 'prev.log')
+  } catch {
+    // app.getPath не готов (очень ранний boot) — отложим, console продолжит.
+  }
+}
+
+function rotateIfNeeded(): void {
+  if (!logPath) return
+  try {
+    if (!existsSync(logPath)) return
+    const size = statSync(logPath).size
+    if (size < ROTATE_AT_BYTES) return
+    if (existsSync(prevPath)) unlinkSync(prevPath)
+    renameSync(logPath, prevPath)
+  } catch {
+    // не критично — продолжим писать в latest.log с overflow
+  }
+}
+
+function ts(): string {
+  return new Date().toISOString()
+}
+
+function levelTag(l: Level): string {
+  return l.toUpperCase().padEnd(5, ' ')
+}
+
+function write(level: Level, msg: string, extra?: unknown): void {
+  // Always dup to console for dev. structuredClone-style serialize:
+  const line = `[${ts()}] ${levelTag(level)} ${msg}${
+    extra !== undefined ? ' ' + safeStringify(extra) : ''
+  }\n`
+  switch (level) {
+    case 'error':
+      console.error(line.trimEnd())
+      break
+    case 'warn':
+      console.warn(line.trimEnd())
+      break
+    case 'debug':
+    case 'info':
+    default:
+      console.log(line.trimEnd())
+  }
+  ensurePaths()
+  rotateIfNeeded()
+  if (!logPath) return
+  try {
+    appendFileSync(logPath, line, 'utf-8')
+  } catch {
+    // Если AV держит файл — переживём, в console уже залогировали.
+  }
+}
+
+function safeStringify(v: unknown): string {
+  if (v instanceof Error) {
+    return v.stack ?? `${v.name}: ${v.message}`
+  }
+  try {
+    return JSON.stringify(v)
+  } catch {
+    return String(v)
+  }
+}
+
+const DEBUG_ENABLED = process.env.LAUDE_DEBUG === '1'
+
+export const log = {
+  debug: (msg: string, extra?: unknown): void => {
+    if (DEBUG_ENABLED) write('debug', msg, extra)
+  },
+  info: (msg: string, extra?: unknown): void => write('info', msg, extra),
+  warn: (msg: string, extra?: unknown): void => write('warn', msg, extra),
+  error: (msg: string, extra?: unknown): void => write('error', msg, extra)
+}
+
+/** Путь к логам (для диагностики). Возвращает пустую строку до initLogger(). */
+export function getLogDir(): string {
+  return logDir
+}

src/main/meeting-detect.test.ts

@@ -0,0 +1,109 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+
+/**
+ * Тесты эвристики «человек на ВКС». Мокаем `node:child_process.exec`
+ * (через него идёт `tasklist`), electron BrowserWindow (broadcast no-op) и
+ * logger. resetModules + dynamic import в каждом тесте — чтобы сбросить
+ * module-level кэш (`cachedActive`, `lastCheckAt`).
+ */
+
+type ExecCb = (err: Error | null, res?: { stdout: string }) => void
+
+const h = vi.hoisted(() => ({
+  // Текущая реализация exec для конкретного теста.
+  execImpl: ((_cmd: string, _opts: unknown, cb: ExecCb) =>
+    cb(null, { stdout: '' })) as (
+    cmd: string,
+    opts: unknown,
+    cb: ExecCb
+  ) => void,
+  calls: 0,
+  log: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() }
+}))
+
+vi.mock('node:child_process', () => ({
+  exec: (cmd: string, opts: unknown, cb: ExecCb) => {
+    h.calls += 1
+    h.execImpl(cmd, opts, cb)
+  }
+}))
+vi.mock('electron', () => ({ BrowserWindow: { getAllWindows: () => [] } }))
+vi.mock('./logger', () => ({ log: h.log }))
+
+/** CSV-строка tasklist для заданного набора .exe. */
+function csv(...procs: string[]): string {
+  return procs.map((p) => `"${p}","1234","Console","1","85,432 K"`).join('\r\n')
+}
+
+async function load(): Promise<typeof import('./meeting-detect')> {
+  return import('./meeting-detect')
+}
+
+beforeEach(() => {
+  vi.resetModules()
+  h.calls = 0
+  h.execImpl = (_cmd, _opts, cb) => cb(null, { stdout: '' })
+  h.log.info.mockClear()
+  h.log.warn.mockClear()
+})
+
+afterEach(() => {
+  vi.restoreAllMocks()
+})
+
+describe('isMeetingActive', () => {
+  it('детектит zoom.exe', async () => {
+    h.execImpl = (_c, _o, cb) => cb(null, { stdout: csv('zoom.exe') })
+    const { isMeetingActive } = await load()
+    expect(await isMeetingActive()).toBe(true)
+  })
+
+  it('детектит новые Teams (ms-teams.exe)', async () => {
+    h.execImpl = (_c, _o, cb) =>
+      cb(null, { stdout: csv('explorer.exe', 'ms-teams.exe') })
+    const { isMeetingActive } = await load()
+    expect(await isMeetingActive()).toBe(true)
+  })
+
+  it('возвращает false когда ВКС-процессов нет', async () => {
+    h.execImpl = (_c, _o, cb) =>
+      cb(null, { stdout: csv('explorer.exe', 'code.exe', 'chrome.exe') })
+    const { isMeetingActive } = await load()
+    expect(await isMeetingActive()).toBe(false)
+  })
+
+  it('кэширует результат в пределах CACHE_MS (exec вызывается один раз)', async () => {
+    h.execImpl = (_c, _o, cb) => cb(null, { stdout: csv('discord.exe') })
+    const { isMeetingActive } = await load()
+    await isMeetingActive()
+    await isMeetingActive()
+    expect(h.calls).toBe(1)
+  })
+
+  it('при падении tasklist возвращает false и логирует warn', async () => {
+    h.execImpl = (_c, _o, cb) => cb(new Error('ETIMEDOUT'))
+    const { isMeetingActive } = await load()
+    expect(await isMeetingActive()).toBe(false)
+    expect(h.log.warn).toHaveBeenCalled()
+  })
+
+  it('isMeetingActiveSync отражает последний известный результат', async () => {
+    h.execImpl = (_c, _o, cb) => cb(null, { stdout: csv('webex.exe') })
+    const mod = await load()
+    expect(mod.isMeetingActiveSync()).toBe(false) // до первого запроса
+    await mod.isMeetingActive()
+    expect(mod.isMeetingActiveSync()).toBe(true)
+  })
+
+  it('на не-Windows возвращает false без вызова tasklist', async () => {
+    const original = process.platform
+    Object.defineProperty(process, 'platform', { value: 'linux' })
+    try {
+      const { isMeetingActive } = await load()
+      expect(await isMeetingActive()).toBe(false)
+      expect(h.calls).toBe(0)
+    } finally {
+      Object.defineProperty(process, 'platform', { value: original })
+    }
+  })
+})

src/main/meeting-detect.ts

@@ -0,0 +1,112 @@
+/**
+ * Эвристическое обнаружение «человек на ВКС» по списку запущенных процессов.
+ *
+ * Идея: если запущен Zoom/Teams/Discord/Meet/Webex — пользователь скорее
+ * всего на встрече или собирается зайти. Останавливаем напоминания, чтобы
+ * не прерывать. После «снятия» процессов возобновляем.
+ *
+ * Проверка раз в 30 сек через `tasklist` (CSV-режим, без окна). Не используем
+ * audio capture API / mic state — это потребовало бы Windows-specific
+ * native-модуля; задача fit-for-purpose, не security-critical.
+ *
+ * False positive vs false negative tradeoff: лучше один лишний скип
+ * напоминания, чем один pop-up посреди митинга. Поэтому даже если
+ * процесс запущен, но митинга нет (Teams в фоне) — пауза. Пользователь
+ * это переживёт, обратное — не очень.
+ */
+import { exec } from 'node:child_process'
+import { promisify } from 'node:util'
+import { BrowserWindow } from 'electron'
+import { IPC } from '@shared/ipc'
+import { log } from './logger'
+
+function broadcast(active: boolean): void {
+  for (const win of BrowserWindow.getAllWindows()) {
+    if (!win.isDestroyed()) win.webContents.send(IPC.evtMeetingChanged, active)
+  }
+}
+
+const execAsync = promisify(exec)
+
+/**
+ * Имена процессов (Windows .exe). Регистр игнорируется при сравнении.
+ * Покрываем основные VOIP-приложения для индустрии WFH.
+ */
+const MEETING_PROCESSES = new Set([
+  'zoom.exe',
+  'teams.exe',
+  'ms-teams.exe', // новые Teams 2.0
+  'discord.exe',
+  'webex.exe',
+  'webexmta.exe',
+  'meet.exe', // Google Meet desktop (редкость)
+  'slack.exe', // huddle
+  'skype.exe',
+  'gotomeeting.exe',
+  'whereby.exe'
+])
+
+let cachedActive = false
+let lastCheckAt = 0
+const CACHE_MS = 30_000
+
+/**
+ * Проверяет, запущен ли хотя бы один из meeting-процессов. Кеширует
+ * результат на CACHE_MS, чтобы tasklist не дёргался каждую секунду из
+ * scheduler-tick'а.
+ */
+export async function isMeetingActive(): Promise<boolean> {
+  if (process.platform !== 'win32') return false
+  const now = Date.now()
+  if (now - lastCheckAt < CACHE_MS) return cachedActive
+  lastCheckAt = now
+  try {
+    // CSV без заголовков (/NH), скрытое окно.
+    const { stdout } = await execAsync('tasklist /FO CSV /NH', {
+      windowsHide: true,
+      maxBuffer: 4 * 1024 * 1024, // tasklist бывает большой
+      // Если tasklist подвис (повреждённый WMI, загруженная система) — exec
+      // сам прибьёт процесс и уйдёт в catch. Без таймаута зависшие child
+      // накапливались бы при каждом refresh.
+      timeout: 4000,
+      killSignal: 'SIGKILL'
+    })
+    const lower = stdout.toLowerCase()
+    for (const proc of MEETING_PROCESSES) {
+      // Простой substring-match достаточен: формат CSV-row
+      // "zoom.exe","12345","Console","1","85,432 K".
+      if (lower.includes(`"${proc}",`)) {
+        if (!cachedActive) {
+          log.info(`[meeting] detected ${proc} — pausing reminders`)
+          broadcast(true)
+        }
+        cachedActive = true
+        return true
+      }
+    }
+    if (cachedActive) {
+      log.info('[meeting] no meeting processes — resuming reminders')
+      broadcast(false)
+    }
+    cachedActive = false
+    return false
+  } catch (e) {
+    // tasklist может фейлиться на нестандартных образах Windows. Лучше
+    // продолжить работу как обычно (не паузить), чем глушить напоминания
+    // навсегда.
+    log.warn('[meeting] tasklist failed, assuming no meeting', e)
+    cachedActive = false
+    return false
+  }
+}
+
+/** Синхронный «последнее известное значение» без запроса. Используется
+ * в scheduler-tick'е — он не async. Background refresh идёт отдельно. */
+export function isMeetingActiveSync(): boolean {
+  return cachedActive
+}
+
+/** Background refresh, дёргаем из scheduler'а. Не await'им. */
+export function refreshMeetingState(): void {
+  void isMeetingActive()
+}

src/main/scheduler.test.ts

@@ -0,0 +1,167 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import type {
+  Exercise,
+  HistoryEntry,
+  QuietHours,
+  Settings
+} from '@shared/types'
+import { DEFAULT_SETTINGS } from '@shared/types'
+
+/**
+ * Тесты gating-логики scheduler'а. Дёргаем публичный `forceCheck()` (он
+ * сбрасывает lastCheckAt и прогоняет tick → checkDueExercises) и проверяем,
+ * вызвался ли `fireReminder`. Стор/нотификации/meeting/adaptive замоканы.
+ */
+
+const h = vi.hoisted(() => ({
+  settings: null as Settings | null,
+  exercises: [] as Exercise[],
+  history: [] as HistoryEntry[],
+  meetingActive: false,
+  fireReminder: vi.fn(),
+  updateExercise: vi.fn(),
+  broadcastState: vi.fn(),
+  refreshMeetingState: vi.fn(),
+  adjustNextFireAt: vi.fn((_ex: Exercise, candidate: number) => candidate)
+}))
+
+vi.mock('electron', () => ({
+  powerMonitor: { on: vi.fn() },
+  BrowserWindow: { getAllWindows: () => [] }
+}))
+vi.mock('./store', () => ({
+  getSettings: () => h.settings,
+  getExercises: () => h.exercises,
+  getHistory: () => h.history,
+  updateExercise: (id: string, patch: Partial<Exercise>) => {
+    h.updateExercise(id, patch)
+    const ex = h.exercises.find((e) => e.id === id)
+    return ex ? { ...ex, ...patch } : undefined
+  }
+}))
+vi.mock('./notifications', () => ({ fireReminder: h.fireReminder }))
+vi.mock('./state-actions', () => ({ broadcastState: h.broadcastState }))
+vi.mock('./meeting-detect', () => ({
+  isMeetingActiveSync: () => h.meetingActive,
+  refreshMeetingState: h.refreshMeetingState
+}))
+vi.mock('./adaptive', () => ({ adjustNextFireAt: h.adjustNextFireAt }))
+
+function makeExercise(over: Partial<Exercise> = {}): Exercise {
+  return {
+    id: 'ex1',
+    name: 'Приседания',
+    reps: 10,
+    icon: 'Activity',
+    intervalMinutes: 30,
+    enabled: true,
+    nextFireAt: Date.now() - 1000, // due by default
+    ...over
+  }
+}
+
+/** Тихие часы, гарантированно покрывающие текущий момент (без wrap). */
+function quietWindowAroundNow(): QuietHours {
+  const now = new Date()
+  const cur = now.getHours() * 60 + now.getMinutes()
+  const fromMin = Math.max(0, cur - 60)
+  const toMin = Math.min(1439, cur + 60)
+  const fmt = (m: number): string =>
+    `${String(Math.floor(m / 60)).padStart(2, '0')}:${String(m % 60).padStart(
+      2,
+      '0'
+    )}`
+  return { enabled: true, from: fmt(fromMin), to: fmt(toMin), days: [] }
+}
+
+async function loadScheduler(): Promise<typeof import('./scheduler')> {
+  return import('./scheduler')
+}
+
+beforeEach(() => {
+  vi.resetModules()
+  h.settings = { ...DEFAULT_SETTINGS }
+  h.exercises = []
+  h.history = []
+  h.meetingActive = false
+  h.fireReminder.mockClear()
+  h.updateExercise.mockClear()
+  h.broadcastState.mockClear()
+  h.refreshMeetingState.mockClear()
+  h.adjustNextFireAt.mockClear()
+})
+
+describe('checkDueExercises gating', () => {
+  it('не fire-ит когда globalEnabled=false', async () => {
+    h.settings = { ...DEFAULT_SETTINGS, globalEnabled: false }
+    h.exercises = [makeExercise()]
+    const { forceCheck } = await loadScheduler()
+    forceCheck()
+    expect(h.fireReminder).not.toHaveBeenCalled()
+  })
+
+  it('не fire-ит внутри тихих часов', async () => {
+    h.settings = { ...DEFAULT_SETTINGS, quietHours: quietWindowAroundNow() }
+    h.exercises = [makeExercise()]
+    const { forceCheck } = await loadScheduler()
+    forceCheck()
+    expect(h.fireReminder).not.toHaveBeenCalled()
+  })
+
+  it('не fire-ит когда активна ВКС (meetingAutoPause)', async () => {
+    h.settings = { ...DEFAULT_SETTINGS, meetingAutoPause: true }
+    h.meetingActive = true
+    h.exercises = [makeExercise()]
+    const { forceCheck } = await loadScheduler()
+    forceCheck()
+    expect(h.refreshMeetingState).toHaveBeenCalled()
+    expect(h.fireReminder).not.toHaveBeenCalled()
+  })
+
+  it('fire-ит готовое к срабатыванию упражнение и шлёт broadcastState', async () => {
+    h.exercises = [makeExercise()]
+    const { forceCheck } = await loadScheduler()
+    forceCheck()
+    expect(h.fireReminder).toHaveBeenCalledTimes(1)
+    expect(h.broadcastState).toHaveBeenCalled()
+  })
+
+  it('пропускает выключенные упражнения', async () => {
+    h.exercises = [makeExercise({ enabled: false })]
+    const { forceCheck } = await loadScheduler()
+    forceCheck()
+    expect(h.fireReminder).not.toHaveBeenCalled()
+  })
+
+  it('не fire-ит упражнение, чьё время ещё не пришло', async () => {
+    h.exercises = [makeExercise({ nextFireAt: Date.now() + 60_000 })]
+    const { forceCheck } = await loadScheduler()
+    forceCheck()
+    expect(h.fireReminder).not.toHaveBeenCalled()
+  })
+
+  it('soft-cap: при закрытой dailyGoal переносит fire, но не показывает', async () => {
+    h.exercises = [makeExercise({ dailyGoal: 20 })]
+    h.history = [
+      {
+        ts: Date.now(),
+        exerciseId: 'ex1',
+        action: 'done',
+        actualReps: 25
+      }
+    ]
+    const { forceCheck } = await loadScheduler()
+    forceCheck()
+    expect(h.fireReminder).not.toHaveBeenCalled()
+    // nextFireAt перенесён (на завтра) — updateExercise вызван.
+    expect(h.updateExercise).toHaveBeenCalled()
+  })
+
+  it('adaptive: применяет adjustNextFireAt к кандидату', async () => {
+    h.exercises = [makeExercise({ adaptive: true })]
+    const { forceCheck } = await loadScheduler()
+    forceCheck()
+    expect(h.adjustNextFireAt).toHaveBeenCalled()
+    expect(h.fireReminder).toHaveBeenCalledTimes(1)
+  })
+})

src/main/scheduler.ts

@@ -1,10 +1,30 @@
 import { powerMonitor, BrowserWindow } from 'electron'
 import { IPC } from '@shared/ipc'
-import type { Tick } from '@shared/types'
+import type { Exercise, Tick, HistoryEntry } from '@shared/types'
 import { isQuietAt } from '@shared/types'
-import { getExercises, getSettings, updateExercise } from './store'
+import { getExercises, getHistory, getSettings, updateExercise } from './store'
 import { fireReminder } from './notifications'
 import { broadcastState } from './state-actions'
+import { isMeetingActiveSync, refreshMeetingState } from './meeting-detect'
+import { adjustNextFireAt } from './adaptive'
+
+/**
+ * Сколько reps пользователь сделал по упражнению `ex` за сегодня (local day).
+ * Учитываем actualReps если задано (частичное выполнение), иначе planned reps.
+ */
+function repsDoneToday(ex: Exercise, history: HistoryEntry[]): number {
+  const todayKey = new Date()
+  todayKey.setHours(0, 0, 0, 0)
+  const startMs = todayKey.getTime()
+  let sum = 0
+  for (const e of history) {
+    if (e.action !== 'done') continue
+    if (e.exerciseId !== ex.id) continue
+    if (e.ts < startMs) continue
+    sum += e.actualReps ?? ex.reps
+  }
+  return sum
+}
 
 /**
  * TICK_MS drives the per-second countdown UI; CHECK_MS gates the (cheaper)
@@ -16,10 +36,8 @@ const CHECK_MS = 5000
 let tickHandle: NodeJS.Timeout | null = null
 let powerListenersArmed = false
 let lastCheckAt = 0
-let paused = false
 
 function checkDueExercises(): void {
-  if (paused) return
   const settings = getSettings()
   if (!settings.globalEnabled) return
 
@@ -27,20 +45,50 @@ function checkDueExercises(): void {
   // CHECK_MS pass after the window ends will pick them up.
   if (isQuietAt(settings.quietHours, new Date())) return
 
+  // Авто-пауза на встречах. Sync-чтение кеша (последнее значение); refresh
+  // запускаем в фоне чтобы кеш «зрел» к следующему tick'у. На холодном
+  // старте кеш false — первое срабатывание может прийти в момент митинга,
+  // но 30 сек спустя система догонит и больше не будет fire'ить.
+  if (settings.meetingAutoPause) {
+    refreshMeetingState()
+    if (isMeetingActiveSync()) return
+  }
+
   const now = Date.now()
   const exercises = getExercises()
+  // history запрашивается если у какого-нибудь упражнения есть
+  // dailyGoal или adaptive: false — иначе экономим IPC-нагрузку.
+  const needsHistory = exercises.some(
+    (e) => e.dailyGoal !== undefined || e.adaptive
+  )
+  const history = needsHistory ? getHistory() : []
   let anyFired = false
   for (const ex of exercises) {
     if (!ex.enabled) continue
-    if (ex.nextFireAt <= now) {
+    if (ex.nextFireAt > now) continue
-      const updated = updateExercise(ex.id, {
+    // Soft cap: если dailyGoal задан и уже выполнен — переносим
-        nextFireAt: now + ex.intervalMinutes * 60_000
+    // следующий fire на «начало завтра» (без повторных проверок до утра).
-      })
+    if (ex.dailyGoal !== undefined && ex.dailyGoal > 0) {
-      if (updated) {
+      const done = repsDoneToday(ex, history)
-        anyFired = true
+      if (done >= ex.dailyGoal) {
-        fireReminder(updated, settings.notificationMode)
+        const tomorrow = new Date()
+        tomorrow.setHours(0, 0, 0, 0)
+        tomorrow.setDate(tomorrow.getDate() + 1)
+        updateExercise(ex.id, { nextFireAt: tomorrow.getTime() })
+        continue
       }
     }
+    // Базовый candidate. Если adaptive — сдвигаем на «хороший» час
+    // по исторической статистике успеха/скипов.
+    let nextFireAt = now + ex.intervalMinutes * 60_000
+    if (ex.adaptive) {
+      nextFireAt = adjustNextFireAt(ex, nextFireAt, history)
+    }
+    const updated = updateExercise(ex.id, { nextFireAt })
+    if (updated) {
+      anyFired = true
+      fireReminder(updated, settings.notificationMode)
+    }
   }
   // Push fresh state so the renderer's Dashboard/Exercises pages don't show
   // stale `nextFireAt` until the next state-changing IPC arrives.
@@ -98,14 +146,6 @@ export function stopScheduler(): void {
   }
 }
 
-export function setPaused(value: boolean): void {
-  paused = value
-}
-
-export function isPaused(): boolean {
-  return paused
-}
-
 export function forceCheck(): void {
   lastCheckAt = 0
   tick()

src/main/state-actions.ts

@@ -1,14 +1,24 @@
 import { BrowserWindow } from 'electron'
 import { IPC } from '@shared/ipc'
-import { getExercises, getState, updateExercise } from './store'
+import { getExercises, getStateForRenderer, updateExercise } from './store'
 
 export function broadcastState(): void {
-  const state = getState()
+  // Используем variant без `history` — иначе при 10k записей через IPC
+  // на каждый markDone летит 500KB JSON × M подписчиков. Renderer
+  // запрашивает историю отдельно через IPC.getHistory.
+  const state = getStateForRenderer()
   for (const win of BrowserWindow.getAllWindows()) {
     if (!win.isDestroyed()) win.webContents.send(IPC.evtStateChanged, state)
   }
 }
 
+/** Сигнализирует renderer'у что историю надо перетянуть. */
+export function broadcastHistoryChanged(): void {
+  for (const win of BrowserWindow.getAllWindows()) {
+    if (!win.isDestroyed()) win.webContents.send(IPC.evtHistoryChanged)
+  }
+}
+
 export function snoozeAll(minutes: number): void {
   const now = Date.now()
   for (const ex of getExercises()) {

src/main/store.test.ts

@@ -0,0 +1,198 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import {
+  mkdtempSync,
+  rmSync,
+  writeFileSync,
+  existsSync,
+  readdirSync
+} from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+/**
+ * Тесты persistence-слоя. Мокаем electron.app.getPath на временную директорию
+ * (новую на каждый тест) и logger. resetModules + dynamic import сбрасывают
+ * module-level `cache`/`storePath`, чтобы тесты не текли друг в друга.
+ */
+
+const h = vi.hoisted(() => ({
+  userData: '',
+  log: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() }
+}))
+
+vi.mock('electron', () => ({
+  app: {
+    getPath: () => h.userData,
+    getVersion: () => '0.0.0-test'
+  }
+}))
+vi.mock('./logger', () => ({ log: h.log }))
+
+async function load(): Promise<typeof import('./store')> {
+  return import('./store')
+}
+
+function statePath(): string {
+  return join(h.userData, 'app-state.json')
+}
+
+function corruptFiles(): string[] {
+  return readdirSync(h.userData).filter((f) => f.includes('.corrupt-'))
+}
+
+beforeEach(() => {
+  vi.resetModules()
+  h.userData = mkdtempSync(join(tmpdir(), 'laude-store-'))
+  h.log.error.mockClear()
+  h.log.warn.mockClear()
+})
+
+afterEach(() => {
+  try {
+    rmSync(h.userData, { recursive: true, force: true })
+  } catch {
+    /* ignore */
+  }
+})
+
+describe('store · cold start', () => {
+  it('создаёт app-state.json с примерами упражнений на первом запуске', async () => {
+    const { getState } = await load()
+    const state = getState()
+    expect(state.exercises.length).toBeGreaterThan(0)
+    expect(existsSync(statePath())).toBe(true)
+  })
+})
+
+describe('store · corrupt file quarantine', () => {
+  it('битый JSON уносится в .corrupt-* и стартует чистый state', async () => {
+    writeFileSync(statePath(), '{ this is : not json', 'utf-8')
+    const { getState } = await load()
+    const state = getState()
+    expect(state.exercises.length).toBeGreaterThan(0) // initial
+    expect(corruptFiles().length).toBe(1)
+    expect(h.log.error).toHaveBeenCalled()
+  })
+
+  it('валидный JSON, но не объект (массив) — тоже карантин', async () => {
+    writeFileSync(statePath(), '[1,2,3]', 'utf-8')
+    const { getState } = await load()
+    expect(getState().exercises.length).toBeGreaterThan(0)
+    expect(corruptFiles().length).toBe(1)
+  })
+})
+
+describe('store · coerce / migrations', () => {
+  it('подставляет дефолтные settings когда их нет в файле', async () => {
+    writeFileSync(
+      statePath(),
+      JSON.stringify({ exercises: [], challenges: [], history: [] }),
+      'utf-8'
+    )
+    const { getSettings } = await load()
+    const s = getSettings()
+    expect(s.globalEnabled).toBeDefined()
+    expect(s.notificationMode).toBeDefined()
+    expect(s.snoozeMinutes).toBeGreaterThan(0)
+  })
+
+  it('файл без __schemaVersion грузится без потери данных', async () => {
+    const ex = {
+      id: 'x1',
+      name: 'Тест',
+      reps: 10,
+      icon: 'Dumbbell',
+      intervalMinutes: 30,
+      enabled: true,
+      nextFireAt: Date.now() + 1000
+    }
+    writeFileSync(
+      statePath(),
+      JSON.stringify({ exercises: [ex], challenges: [], history: [] }),
+      'utf-8'
+    )
+    const { getExercises } = await load()
+    const list = getExercises()
+    expect(list).toHaveLength(1)
+    expect(list[0].name).toBe('Тест')
+  })
+})
+
+describe('store · history cap', () => {
+  it('обрезает историю когда превышен HISTORY_MAX', async () => {
+    const ex = {
+      id: 'x1',
+      name: 'Приседания',
+      reps: 10,
+      icon: 'Activity',
+      intervalMinutes: 30,
+      enabled: true,
+      nextFireAt: Date.now()
+    }
+    const big = Array.from({ length: 10_005 }, (_unused, i) => ({
+      ts: i,
+      exerciseId: 'x1',
+      action: 'done' as const,
+      reps: 10
+    }))
+    writeFileSync(
+      statePath(),
+      JSON.stringify({ exercises: [ex], challenges: [], history: big }),
+      'utf-8'
+    )
+    const { markDone, getHistory } = await load()
+    markDone('x1')
+    // 10005 + 1 = 10006 > 10000 → slice(-9000)
+    expect(getHistory().length).toBe(9000)
+  })
+})
+
+describe('store · clearHistory', () => {
+  it('удаляет записи старше границы и возвращает количество', async () => {
+    const ex = {
+      id: 'x1',
+      name: 'A',
+      reps: 5,
+      icon: 'Activity',
+      intervalMinutes: 10,
+      enabled: true,
+      nextFireAt: Date.now()
+    }
+    const history = [
+      { ts: 100, exerciseId: 'x1', action: 'done' as const },
+      { ts: 200, exerciseId: 'x1', action: 'done' as const },
+      { ts: 300, exerciseId: 'x1', action: 'done' as const }
+    ]
+    writeFileSync(
+      statePath(),
+      JSON.stringify({ exercises: [ex], challenges: [], history }),
+      'utf-8'
+    )
+    const { clearHistory, getHistory } = await load()
+    const removed = clearHistory(250)
+    expect(removed).toBe(2)
+    expect(getHistory().map((e) => e.ts)).toEqual([300])
+  })
+
+  it('отказывается чистить без явной границы (защита от полного wipe)', async () => {
+    const { clearHistory } = await load()
+    expect(clearHistory()).toBe(0)
+  })
+})
+
+describe('store · export / import', () => {
+  it('export даёт валидный JSON со схемой; import парсит его обратно', async () => {
+    const { exportState, importState } = await load()
+    const json = exportState()
+    const parsed = JSON.parse(json)
+    expect(typeof parsed.__schemaVersion).toBe('number')
+    expect(parsed.__schemaVersion).toBeGreaterThanOrEqual(1)
+    expect(importState(json)).toBe(true)
+  })
+
+  it('import отклоняет мусор', async () => {
+    const { importState } = await load()
+    expect(importState('not json at all')).toBe(false)
+    expect(importState('42')).toBe(false)
+  })
+})

src/main/store.ts

@@ -17,9 +17,11 @@ import {
   GameId,
   HistoryAction,
   HistoryEntry,
+  PersistedState,
   SAMPLE_EXERCISES,
   Settings
 } from '@shared/types'
+import { log } from './logger'
 
 /**
  * Keep at most this many history entries (≈2.7 years at 10/day).
@@ -30,7 +32,7 @@ const HISTORY_MAX = 10_000
 const WRITE_DEBOUNCE_MS = 1500
 const WRITE_RETRY_DELAYS = [50, 200, 800] // ms backoff on transient EBUSY/EPERM
 
-let cache: AppState | null = null
+let cache: PersistedState | null = null
 let storePath = ''
 let pendingWrite: NodeJS.Timeout | null = null
 
@@ -43,7 +45,7 @@ function getStorePath(): string {
   return storePath
 }
 
-function makeInitial(): AppState {
+function makeInitial(): PersistedState {
   const now = Date.now()
   return {
     exercises: SAMPLE_EXERCISES.map((e) => ({
@@ -88,12 +90,11 @@ function quarantineCorrupt(p: string, reason: string): void {
       .replace(/Z$/, '')
     const dest = `${p}.corrupt-${stamp}`
     renameSync(p, dest)
-    console.error(
+    log.error(
-      `[store] app-state.json was unreadable (${reason}); ` +
+      `[store] app-state.json was unreadable (${reason}); moved to ${dest} and starting fresh.`
-        `moved to ${dest} and starting fresh.`
     )
   } catch (e) {
-    console.error('[store] failed to quarantine corrupt state file:', e)
+    log.error('[store] failed to quarantine corrupt state file', e)
   }
 }
 
@@ -144,8 +145,8 @@ function runMigrations(s: StoredState): StoredState {
   return cursor
 }
 
-/** Coerce a (possibly partial) migrated state into a fully-formed AppState. */
+/** Coerce a (possibly partial) migrated state into a fully-formed PersistedState. */
-function coerce(s: StoredState): AppState {
+function coerce(s: StoredState): PersistedState {
   return {
     exercises: Array.isArray(s.exercises) ? (s.exercises as Exercise[]) : [],
     settings: {
@@ -162,11 +163,12 @@ function coerce(s: StoredState): AppState {
   }
 }
 
-function load(): AppState {
+function load(): PersistedState {
   const p = getStorePath()
   if (!existsSync(p)) {
     const initial = makeInitial()
-    atomicWrite(
+    // Cold path — sync write на инициализации (event-loop ещё не активен).
+    atomicWriteSync(
       p,
       JSON.stringify(
         { __schemaVersion: CURRENT_SCHEMA_VERSION, ...initial },
@@ -180,7 +182,7 @@ function load(): AppState {
   try {
     raw = readFileSync(p, 'utf-8')
   } catch (e) {
-    console.error('[store] cannot read state file:', e)
+    log.error('[store] cannot read state file', e)
     return makeInitial() // do not quarantine — we can't read it anyway
   }
   let parsed: unknown
@@ -197,20 +199,32 @@ function load(): AppState {
   return coerce(runMigrations(parsed))
 }
 
+type AppendOpts = {
+  actualReps?: number
+  /** Planned reps snapshot — иначе после удаления упражнения теряем reps. */
+  reps?: number
+  /** Snapshot названия — для будущего log-view (необязательно). */
+  name?: string
+  /** 'reminder' (default) или 'match'. */
+  source?: import('@shared/types').HistorySource
+}
+
 function appendHistory(
   exerciseId: string,
   action: HistoryAction,
-  actualReps?: number
+  opts: AppendOpts = {}
 ): void {
   const state = getState()
   if (!state.history) state.history = []
   const entry: HistoryEntry = { ts: Date.now(), exerciseId, action }
-  if (actualReps !== undefined) entry.actualReps = actualReps
+  if (opts.actualReps !== undefined) entry.actualReps = opts.actualReps
+  if (opts.reps !== undefined) entry.reps = opts.reps
+  if (opts.name !== undefined) entry.name = opts.name
+  if (opts.source !== undefined) entry.source = opts.source
   state.history.push(entry)
   if (state.history.length > HISTORY_MAX) {
     state.history = state.history.slice(-Math.floor(HISTORY_MAX * 0.9))
   }
-  // Caller schedules the write; appendHistory itself is internal.
 }
 
 export function getHistory(sinceMs?: number): HistoryEntry[] {
@@ -235,8 +249,16 @@ export function clearHistory(beforeTs?: number): number {
 /**
  * Atomically write to `path` via a sibling .tmp file + rename. Retries a few
  * times on transient EBUSY/EPERM (AV/OneDrive holding the file).
+ *
+ * Async version (используется debounced scheduleWrite/flush) — раньше был
+ * busy-loop `while (Date.now() < until)`, который морозил весь main process
+ * на retry-delay (до 800мс). При активном AV это превращалось в видимое
+ * залипание UI. Сейчас sleep через setTimeout-promise.
+ *
+ * Для процесса-выхода используется `atomicWriteSync` — там event-loop уже
+ * не работает, async sleep не сработает.
  */
-function atomicWrite(path: string, contents: string): void {
+async function atomicWrite(path: string, contents: string): Promise<void> {
   const tmp = `${path}.tmp`
   let lastErr: unknown
   for (let i = 0; i <= WRITE_RETRY_DELAYS.length; i++) {
@@ -246,7 +268,6 @@ function atomicWrite(path: string, contents: string): void {
       return
     } catch (e) {
       lastErr = e
-      // best-effort cleanup of the stale .tmp
       try {
         if (existsSync(tmp)) unlinkSync(tmp)
       } catch {
@@ -254,40 +275,97 @@ function atomicWrite(path: string, contents: string): void {
       }
       const delay = WRITE_RETRY_DELAYS[i]
       if (delay === undefined) break
-      // Synchronous sleep — write path is short and called outside the hot loop.
+      await new Promise<void>((r) => setTimeout(r, delay))
-      const until = Date.now() + delay
-      while (Date.now() < until) {
-        /* spin */
-      }
     }
   }
-  console.error('[store] atomic write failed after retries:', lastErr)
+  log.error('[store] atomic write failed after retries', lastErr)
 }
 
-function flush(): void {
+/**
+ * Синхронный вариант для use-cases где event loop уже не работает
+ * (process exit в `before-quit`). При retry — короткий sync sleep, потому
+ * что иначе мы дропнем pending write при exit'е.
+ */
+function atomicWriteSync(path: string, contents: string): void {
+  const tmp = `${path}.tmp`
+  let lastErr: unknown
+  for (let i = 0; i <= WRITE_RETRY_DELAYS.length; i++) {
+    try {
+      writeFileSync(tmp, contents, 'utf-8')
+      renameSync(tmp, path)
+      return
+    } catch (e) {
+      lastErr = e
+      try {
+        if (existsSync(tmp)) unlinkSync(tmp)
+      } catch {
+        /* ignore */
+      }
+      const delay = WRITE_RETRY_DELAYS[i]
+      if (delay === undefined) break
+      // Event-loop остановлен (exit-path), async sleep не вернётся — нужен
+      // блокирующий sync sleep. Atomics.wait на «свежем» буфере всегда уходит
+      // в таймаут (значение совпадает с ожидаемым 0), т.е. честно спит delay мс
+      // без сжигания CPU — в отличие от старого busy-loop.
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, delay)
+    }
+  }
+  log.error('[store] atomic sync write failed after retries', lastErr)
+}
+
+async function flush(): Promise<void> {
   if (!cache) return
   // Persist the schema version alongside the state so future migrations know
   // where to pick up from. The renderer never reads this key.
   const payload = { __schemaVersion: CURRENT_SCHEMA_VERSION, ...cache }
-  atomicWrite(getStorePath(), JSON.stringify(payload, null, 2))
+  await atomicWrite(getStorePath(), JSON.stringify(payload, null, 2))
+}
+
+function flushSync(): void {
+  if (!cache) return
+  const payload = { __schemaVersion: CURRENT_SCHEMA_VERSION, ...cache }
+  atomicWriteSync(getStorePath(), JSON.stringify(payload, null, 2))
 }
 
 function scheduleWrite(): void {
   if (pendingWrite) return
   pendingWrite = setTimeout(() => {
     pendingWrite = null
-    flush()
+    void flush()
   }, WRITE_DEBOUNCE_MS)
   // Don't keep the event loop alive solely for a pending write — `before-quit`
   // calls `flushNow()` and we explicitly want the process to exit on schedule.
   pendingWrite.unref?.()
 }
 
-export function getState(): AppState {
+/**
+ * Internal persisted state — единственный source of truth. Включает историю.
+ * Mutate напрямую (mutations внутри store.ts), затем scheduleWrite().
+ */
+export function getState(): PersistedState {
   if (!cache) cache = load()
   return cache
 }
 
+/**
+ * State для отправки renderer'у. Копия БЕЗ `history` — историю renderer
+ * запрашивает отдельным IPC.getHistory. Раньше каждый markDone/snooze
+ * отправлял весь state через evtStateChanged, и при 10k entries в истории
+ * это 500KB JSON × N IPC mutations подряд → заметный лаг.
+ *
+ * Возвращаемая копия безопасна для мутации (ipc.ts накладывает на settings
+ * актуальное OS-значение startWithWindows) — мы НЕ мутируем cache.
+ */
+export function getStateForRenderer(): AppState {
+  const p = getState()
+  return {
+    exercises: p.exercises,
+    settings: p.settings,
+    challenges: p.challenges,
+    gamesEnabled: p.gamesEnabled
+  }
+}
+
 export function getSettings(): Settings {
   return getState().settings
 }
@@ -359,7 +437,12 @@ export function markDone(
   if (!ex) return undefined
   ex.lastDoneAt = Date.now()
   ex.nextFireAt = Date.now() + ex.intervalMinutes * 60_000
-  appendHistory(id, 'done', actualReps)
+  appendHistory(id, 'done', {
+    actualReps,
+    reps: ex.reps,
+    name: ex.name,
+    source: 'reminder'
+  })
   scheduleWrite()
   return ex
 }
@@ -369,7 +452,7 @@ export function snooze(id: string, minutes: number): Exercise | undefined {
   const ex = state.exercises.find((e) => e.id === id)
   if (!ex) return undefined
   ex.nextFireAt = Date.now() + minutes * 60_000
-  appendHistory(id, 'snooze')
+  appendHistory(id, 'snooze', { reps: ex.reps, name: ex.name })
   scheduleWrite()
   return ex
 }
@@ -379,17 +462,36 @@ export function skip(id: string): Exercise | undefined {
   const ex = state.exercises.find((e) => e.id === id)
   if (!ex) return undefined
   ex.nextFireAt = Date.now() + ex.intervalMinutes * 60_000
-  appendHistory(id, 'skip')
+  appendHistory(id, 'skip', { reps: ex.reps, name: ex.name })
   scheduleWrite()
   return ex
 }
 
+/**
+ * Записать выполнение челленджа из match summary в историю. Не привязано
+ * к конкретному Exercise (челлендж может ссылаться на упражнение, которое
+ * пользователь даже не создал). Используем синтетический id 'challenge:<id>'.
+ */
+export function markChallengeDone(challengeId: string, reps: number): void {
+  const state = getState()
+  const ch = state.challenges.find((c) => c.id === challengeId)
+  appendHistory(`challenge:${challengeId}`, 'done', {
+    actualReps: reps,
+    reps,
+    name: ch?.exerciseName ?? ch?.name,
+    source: 'match'
+  })
+  scheduleWrite()
+}
+
 export function flushNow(): void {
   if (pendingWrite) {
     clearTimeout(pendingWrite)
     pendingWrite = null
   }
-  flush()
+  // before-quit вызывает нас когда event-loop уже на пути к выходу — async
+  // promise не успеет resolved, поэтому sync.
+  flushSync()
 }
 
 export function getChallenges(): Challenge[] {
@@ -436,3 +538,56 @@ export function setGameEnabled(id: GameId, enabled: boolean): void {
   state.gamesEnabled = { ...state.gamesEnabled, [id]: enabled }
   scheduleWrite()
 }
+
+// ----- Export / Import -----
+
+/**
+ * Полный snapshot persisted-state (включая историю и schema-version).
+ * Используется для backup'а или переноса на другую машину.
+ */
+export function exportState(): string {
+  const state = getState()
+  return JSON.stringify(
+    {
+      __schemaVersion: CURRENT_SCHEMA_VERSION,
+      __exportedAt: new Date().toISOString(),
+      __appVersion: app.getVersion(),
+      ...state
+    },
+    null,
+    2
+  )
+}
+
+/**
+ * Импорт snapshot'а. Перезаписывает текущий state. Возвращает true при
+ * успехе. Идёт через тот же coerce + runMigrations что и load() — это
+ * валидирует тип/диапазоны.
+ *
+ * НЕ объединяет с текущим state (merge сложен: дубликаты id, конфликты
+ * settings) — простое replace. Перед импортом UI должен спросить
+ * подтверждение.
+ */
+export function importState(raw: string): boolean {
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(raw)
+  } catch (e) {
+    log.warn('[store] import: invalid JSON', e)
+    return false
+  }
+  if (!isValidParsed(parsed)) {
+    log.warn('[store] import: expected object')
+    return false
+  }
+  try {
+    const migrated = runMigrations(parsed)
+    const coerced = coerce(migrated)
+    cache = coerced
+    flushSync()
+    return true
+  } catch (e) {
+    log.error('[store] import: coerce/migrate failed', e)
+    return false
+  }
+}

src/main/tray.ts

@@ -1,9 +1,9 @@
 import { Tray, Menu, nativeImage, app } from 'electron'
 import { join } from 'node:path'
 import { showMainWindow } from './windows'
-import { isPaused, setPaused, forceCheck } from './scheduler'
+import { forceCheck } from './scheduler'
-import { snoozeAll } from './state-actions'
+import { broadcastState, snoozeAll } from './state-actions'
-import { getSettings } from './store'
+import { getSettings, updateSettings } from './store'
 import type { Language } from '@shared/types'
 
 let tray: Tray | null = null
@@ -69,16 +69,21 @@ export function createTray(): Tray {
 
 export function refreshMenu(): void {
   if (!tray) return
-  const paused = isPaused()
+  // Single source of truth — settings.globalEnabled. Раньше tray держал
+  // отдельный scheduler-local `paused` flag, который не синхронизировался
+  // с Dashboard'ом (там кнопка читает globalEnabled). Теперь оба пути
+  // правят одно поле.
+  const paused = !getSettings().globalEnabled
   const menu = Menu.buildFromTemplate([
     { label: trayLabel('open'), click: () => showMainWindow() },
     { type: 'separator' },
     {
       label: paused ? trayLabel('resume') : trayLabel('pause'),
       click: () => {
-        setPaused(!paused)
+        updateSettings({ globalEnabled: paused }) // toggle
+        broadcastState() // чтобы Dashboard перерисовал кнопку сразу
         refreshMenu()
-        if (!paused) forceCheck()
+        if (paused) forceCheck() // resuming — догнать пропущенные fires
       }
     },
     {

src/main/updater.ts

@@ -2,6 +2,7 @@ import { app, BrowserWindow } from 'electron'
 import { autoUpdater } from 'electron-updater'
 import { IPC } from '@shared/ipc'
 import type { UpdaterStatus } from '@shared/types'
+import { log } from './logger'
 
 let currentStatus: UpdaterStatus = { kind: 'idle' }
 let lastCheckedAt: number | undefined
@@ -98,7 +99,7 @@ export function initUpdater(): void {
     if (silentMode) {
       // Background check failed — keep previous status, don't show red banner.
       // Will retry on the next hourly tick.
-      console.warn('[updater] silent check failed:', message)
+      log.warn('[updater] silent check failed', message)
       return
     }
     setStatus({ kind: 'error', message })
@@ -126,7 +127,15 @@ async function bootCheckWithRetry(): Promise<void> {
       return // success
     }
     const delay = BOOT_RETRY_DELAYS[attempt]
-    if (delay === undefined) return // exhausted retries
+    if (delay === undefined) {
+      // Исчерпали ретраи — раньше сдавались молча. Логируем, чтобы при
+      // диагностике было видно «boot-check так и не достучался». Следующая
+      // попытка — на ближайшем hourly-тике.
+      log.warn(
+        '[updater] boot check exhausted retries — will retry on hourly tick'
+      )
+      return
+    }
     await new Promise((r) => setTimeout(r, delay))
   }
 }
@@ -148,7 +157,7 @@ export async function checkForUpdates(
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err)
     if (silentMode) {
-      console.warn('[updater] silent check failed (sync):', message)
+      log.warn('[updater] silent check failed (sync)', message)
     } else {
       setStatus({ kind: 'error', message })
     }
@@ -172,5 +181,12 @@ export async function downloadUpdate(): Promise<void> {
 
 export function quitAndInstall(): void {
   if (!app.isPackaged) return
-  autoUpdater.quitAndInstall()
+  // (isSilent=true, isForceRunAfter=true):
+  //   - isSilent: NSIS работает без UI-диалогов установки → restart занимает
+  //     ~1-2 сек вместо ~5-10 (без чёрного окна установщика на половину экрана).
+  //   - isForceRunAfter: гарантируем что после установки приложение запустится
+  //     автоматически, даже если в NSIS-конфиге runAfterFinish был выключен
+  //     для этого сценария. Без этого пользователь нажал «Рестарт» — и остался
+  //     без открытого приложения.
+  autoUpdater.quitAndInstall(true, true)
 }

src/main/validate.test.ts

@@ -0,0 +1,467 @@
+/**
+ * Тесты для IPC validation layer.
+ *
+ * Этот слой — security-boundary между renderer и main. Если он сломается,
+ * compromised renderer сможет писать в стор NaN, отрицательные, Infinity,
+ * сверхдлинные строки или undefined-enum'ы. Поэтому покрытие важно для:
+ *
+ *   1. Тип-проверок (строка/число/булево/массив)
+ *   2. Range-checks (reps ∈ [1,9999], minutes ∈ [1,1440] и т.д.)
+ *   3. Enum allowlist (theme/lang/notify-mode/stat)
+ *   4. Edge cases: NaN, Infinity, MAX_SAFE_INTEGER, 0, отрицательные, длина строк
+ *   5. Partial-patch semantics (отсутствие поля ≠ невалидное значение)
+ *   6. Сложный nested case: quietHours с HH:MM regex и dedup days
+ */
+import { describe, expect, it } from 'vitest'
+import {
+  validateExerciseInput,
+  validateExercisePatch,
+  validateChallengeInput,
+  validateChallengePatch,
+  validateSettingsPatch,
+  validateId,
+  validateActualReps,
+  validateSnoozeMinutes
+} from './validate'
+
+const validExercise = {
+  name: 'Push-ups',
+  reps: 10,
+  intervalMinutes: 30,
+  icon: 'Dumbbell',
+  enabled: true
+}
+
+describe('validateExerciseInput', () => {
+  it('accepts a fully-formed valid input', () => {
+    expect(validateExerciseInput(validExercise)).toEqual(validExercise)
+  })
+
+  it('rejects non-objects', () => {
+    expect(validateExerciseInput(null)).toBeNull()
+    expect(validateExerciseInput(undefined)).toBeNull()
+    expect(validateExerciseInput('string')).toBeNull()
+    expect(validateExerciseInput(42)).toBeNull()
+    expect(validateExerciseInput([])).toBeNull() // arrays not allowed
+  })
+
+  it('rejects missing required fields', () => {
+    expect(validateExerciseInput({ ...validExercise, name: undefined })).toBeNull()
+    expect(validateExerciseInput({ ...validExercise, reps: undefined })).toBeNull()
+    expect(
+      validateExerciseInput({ ...validExercise, intervalMinutes: undefined })
+    ).toBeNull()
+  })
+
+  it('rejects out-of-range reps', () => {
+    expect(validateExerciseInput({ ...validExercise, reps: 0 })).toBeNull()
+    expect(validateExerciseInput({ ...validExercise, reps: -1 })).toBeNull()
+    expect(validateExerciseInput({ ...validExercise, reps: 10_000 })).toBeNull()
+    expect(validateExerciseInput({ ...validExercise, reps: NaN })).toBeNull()
+    expect(
+      validateExerciseInput({ ...validExercise, reps: Infinity })
+    ).toBeNull()
+  })
+
+  it('truncates reps with Math.trunc (5.7 → 5)', () => {
+    const r = validateExerciseInput({ ...validExercise, reps: 5.7 })
+    expect(r?.reps).toBe(5)
+  })
+
+  it('rejects out-of-range intervalMinutes (> 24h)', () => {
+    expect(
+      validateExerciseInput({ ...validExercise, intervalMinutes: 0 })
+    ).toBeNull()
+    expect(
+      validateExerciseInput({ ...validExercise, intervalMinutes: 1441 })
+    ).toBeNull()
+    expect(
+      validateExerciseInput({ ...validExercise, intervalMinutes: -1 })
+    ).toBeNull()
+  })
+
+  it('rejects empty name', () => {
+    expect(validateExerciseInput({ ...validExercise, name: '' })).toBeNull()
+  })
+
+  it('rejects name longer than MAX_STR_LEN (200)', () => {
+    expect(
+      validateExerciseInput({ ...validExercise, name: 'x'.repeat(201) })
+    ).toBeNull()
+  })
+
+  it('accepts name exactly at MAX_STR_LEN', () => {
+    const r = validateExerciseInput({ ...validExercise, name: 'x'.repeat(200) })
+    expect(r?.name).toHaveLength(200)
+  })
+
+  it('defaults icon to Activity if missing', () => {
+    const { icon: _ignored, ...rest } = validExercise
+    void _ignored
+    expect(validateExerciseInput(rest)?.icon).toBe('Activity')
+  })
+
+  it('defaults enabled to true if missing', () => {
+    const { enabled: _ignored, ...rest } = validExercise
+    void _ignored
+    expect(validateExerciseInput(rest)?.enabled).toBe(true)
+  })
+
+  // Дизайн validateExerciseInput: required-поля (name/reps/intervalMinutes)
+  // строгие — невалидное значение reject'ит весь input. Optional-поля
+  // (icon/enabled) lenient — невалидное молча подменяется дефолтом. Это
+  // фиксирует контракт: malicious renderer не сможет создать запись с
+  // reps=-1, но если он пришлёт `enabled: 'yes'`, получит просто enabled=true.
+  it('coerces invalid enabled to true (lenient default for optional fields)', () => {
+    expect(
+      validateExerciseInput({ ...validExercise, enabled: 'yes' })?.enabled
+    ).toBe(true)
+    expect(
+      validateExerciseInput({ ...validExercise, enabled: 1 })?.enabled
+    ).toBe(true)
+  })
+
+  // А вот в patch optional-поля строгие — нет defaults, есть `if (v ===
+  // undefined) return null`. Это правильнее: если renderer пришёл с патчем,
+  // в котором есть поле, оно должно быть валидным.
+  it('strict patch: rejects invalid enabled in patch (unlike input)', () => {
+    expect(validateExercisePatch({ enabled: 'yes' })).toBeNull()
+    expect(validateExercisePatch({ enabled: 1 })).toBeNull()
+  })
+
+  it('rejects non-string name', () => {
+    expect(validateExerciseInput({ ...validExercise, name: 42 })).toBeNull()
+    expect(validateExerciseInput({ ...validExercise, name: null })).toBeNull()
+  })
+})
+
+describe('validateExercisePatch', () => {
+  it('accepts an empty patch (no-op update)', () => {
+    expect(validateExercisePatch({})).toEqual({})
+  })
+
+  it('accepts partial patches', () => {
+    expect(validateExercisePatch({ reps: 12 })).toEqual({ reps: 12 })
+    expect(validateExercisePatch({ name: 'New' })).toEqual({ name: 'New' })
+    expect(validateExercisePatch({ enabled: false })).toEqual({ enabled: false })
+  })
+
+  it('rejects patch with a single invalid field', () => {
+    // Patch is all-or-nothing: one bad field rejects the whole patch.
+    expect(validateExercisePatch({ name: 'OK', reps: -1 })).toBeNull()
+    expect(validateExercisePatch({ name: '', reps: 10 })).toBeNull()
+  })
+
+  it('rejects non-object', () => {
+    expect(validateExercisePatch(null)).toBeNull()
+    expect(validateExercisePatch([])).toBeNull()
+  })
+
+  it('accepts nextFireAt and lastDoneAt with valid ranges', () => {
+    expect(validateExercisePatch({ nextFireAt: 0 })).toEqual({ nextFireAt: 0 })
+    expect(validateExercisePatch({ lastDoneAt: 1_000_000_000_000 })).toEqual({
+      lastDoneAt: 1_000_000_000_000
+    })
+  })
+
+  it('rejects negative timestamps', () => {
+    expect(validateExercisePatch({ nextFireAt: -1 })).toBeNull()
+    expect(validateExercisePatch({ lastDoneAt: -1 })).toBeNull()
+  })
+
+  it('rejects NaN/Infinity timestamps', () => {
+    expect(validateExercisePatch({ nextFireAt: NaN })).toBeNull()
+    expect(validateExercisePatch({ nextFireAt: Infinity })).toBeNull()
+  })
+})
+
+describe('validateChallengeInput', () => {
+  const valid = {
+    name: 'Deaths → squats',
+    gameId: 'dota2',
+    stat: 'deaths' as const,
+    multiplier: 3,
+    exerciseName: 'Приседания',
+    icon: 'Activity',
+    enabled: true
+  }
+
+  it('accepts valid input', () => {
+    expect(validateChallengeInput(valid)).toEqual(valid)
+  })
+
+  it('rejects unknown stat', () => {
+    expect(validateChallengeInput({ ...valid, stat: 'pizza' })).toBeNull()
+  })
+
+  it('accepts all valid stats', () => {
+    const stats = ['deaths', 'kills', 'assists', 'last_hits', 'denies', 'duration_min']
+    for (const stat of stats) {
+      expect(validateChallengeInput({ ...valid, stat })).not.toBeNull()
+    }
+  })
+
+  it('rejects negative multiplier', () => {
+    expect(validateChallengeInput({ ...valid, multiplier: -1 })).toBeNull()
+  })
+
+  it('rejects multiplier > 1000', () => {
+    expect(validateChallengeInput({ ...valid, multiplier: 1001 })).toBeNull()
+  })
+
+  it('accepts zero multiplier (legitimate "disable" semantics)', () => {
+    expect(validateChallengeInput({ ...valid, multiplier: 0 })?.multiplier).toBe(0)
+  })
+
+  it('accepts fractional multiplier (e.g. 0.5×)', () => {
+    expect(validateChallengeInput({ ...valid, multiplier: 0.5 })?.multiplier).toBe(0.5)
+  })
+})
+
+describe('validateChallengePatch', () => {
+  it('accepts empty patch', () => {
+    expect(validateChallengePatch({})).toEqual({})
+  })
+
+  it('rejects unknown stat in patch', () => {
+    expect(validateChallengePatch({ stat: 'mana' })).toBeNull()
+  })
+})
+
+describe('validateSettingsPatch', () => {
+  it('accepts empty patch', () => {
+    expect(validateSettingsPatch({})).toEqual({})
+  })
+
+  it('accepts each boolean toggle independently', () => {
+    expect(validateSettingsPatch({ globalEnabled: false })).toEqual({
+      globalEnabled: false
+    })
+    expect(validateSettingsPatch({ soundEnabled: true })).toEqual({
+      soundEnabled: true
+    })
+  })
+
+  it('rejects unknown theme', () => {
+    expect(validateSettingsPatch({ theme: 'sepia' })).toBeNull()
+  })
+
+  it('accepts all valid themes', () => {
+    expect(validateSettingsPatch({ theme: 'light' })?.theme).toBe('light')
+    expect(validateSettingsPatch({ theme: 'dark' })?.theme).toBe('dark')
+    expect(validateSettingsPatch({ theme: 'system' })?.theme).toBe('system')
+  })
+
+  it('rejects unknown language', () => {
+    expect(validateSettingsPatch({ language: 'fr' })).toBeNull()
+  })
+
+  it('rejects unknown notification mode', () => {
+    expect(validateSettingsPatch({ notificationMode: 'sms' })).toBeNull()
+  })
+
+  it('rejects out-of-range snoozeMinutes', () => {
+    expect(validateSettingsPatch({ snoozeMinutes: 0 })).toBeNull()
+    expect(validateSettingsPatch({ snoozeMinutes: 1441 })).toBeNull()
+    expect(validateSettingsPatch({ snoozeMinutes: -5 })).toBeNull()
+  })
+
+  it('accepts voicePromptsEnabled boolean', () => {
+    expect(validateSettingsPatch({ voicePromptsEnabled: true })).toEqual({
+      voicePromptsEnabled: true
+    })
+    expect(validateSettingsPatch({ voicePromptsEnabled: false })).toEqual({
+      voicePromptsEnabled: false
+    })
+  })
+
+  it('rejects non-boolean voicePromptsEnabled in patch', () => {
+    expect(validateSettingsPatch({ voicePromptsEnabled: 'yes' })).toBeNull()
+    expect(validateSettingsPatch({ voicePromptsEnabled: 1 })).toBeNull()
+  })
+
+  it('accepts meetingAutoPause boolean', () => {
+    expect(validateSettingsPatch({ meetingAutoPause: true })).toEqual({
+      meetingAutoPause: true
+    })
+  })
+
+  it('rejects non-boolean meetingAutoPause', () => {
+    expect(validateSettingsPatch({ meetingAutoPause: 'yes' })).toBeNull()
+  })
+
+  describe('lastSeenVersion', () => {
+    it('accepts valid semver', () => {
+      const r = validateSettingsPatch({ lastSeenVersion: '0.5.7' })
+      expect(r?.lastSeenVersion).toBe('0.5.7')
+      expect(validateSettingsPatch({ lastSeenVersion: '10.20.30' })).toEqual({
+        lastSeenVersion: '10.20.30'
+      })
+    })
+
+    it('accepts pre-release suffix', () => {
+      const r = validateSettingsPatch({ lastSeenVersion: '0.5.7-beta.1' })
+      expect(r?.lastSeenVersion).toBe('0.5.7-beta.1')
+    })
+
+    it('treats null/undefined as reset to undefined', () => {
+      const r1 = validateSettingsPatch({ lastSeenVersion: null })
+      expect(r1).toEqual({ lastSeenVersion: undefined })
+      const r2 = validateSettingsPatch({ lastSeenVersion: undefined })
+      // 'lastSeenVersion' is `in raw` even if undefined — both treated reset.
+      expect(r2).toEqual({ lastSeenVersion: undefined })
+    })
+
+    it('rejects malformed strings', () => {
+      expect(validateSettingsPatch({ lastSeenVersion: '0.5' })).toBeNull()
+      expect(validateSettingsPatch({ lastSeenVersion: 'v0.5.7' })).toBeNull()
+      expect(validateSettingsPatch({ lastSeenVersion: 'beta' })).toBeNull()
+      expect(validateSettingsPatch({ lastSeenVersion: '' })).toBeNull()
+    })
+
+    it('rejects non-strings', () => {
+      expect(validateSettingsPatch({ lastSeenVersion: 42 })).toBeNull()
+      expect(validateSettingsPatch({ lastSeenVersion: ['1', '0', '0'] })).toBeNull()
+    })
+  })
+
+  describe('quietHours subobject', () => {
+    const baseQh = {
+      enabled: true,
+      from: '22:00',
+      to: '08:00',
+      days: [0, 1, 2, 3, 4, 5, 6]
+    }
+
+    it('accepts a valid quietHours', () => {
+      expect(validateSettingsPatch({ quietHours: baseQh })?.quietHours).toEqual(
+        baseQh
+      )
+    })
+
+    it('rejects non-object quietHours', () => {
+      expect(validateSettingsPatch({ quietHours: 'always' })).toBeNull()
+      expect(validateSettingsPatch({ quietHours: null })).toBeNull()
+    })
+
+    it('rejects malformed HH:MM', () => {
+      expect(
+        validateSettingsPatch({ quietHours: { ...baseQh, from: '2500' } })
+      ).toBeNull()
+      expect(
+        validateSettingsPatch({ quietHours: { ...baseQh, to: 'bedtime' } })
+      ).toBeNull()
+      expect(
+        validateSettingsPatch({ quietHours: { ...baseQh, from: '8' } })
+      ).toBeNull()
+    })
+
+    it('accepts HH:MM with 1-digit hour (9:30)', () => {
+      // Regex is /^\d{1,2}:\d{2}$/ — допускаем «9:30», парсер сам разберётся.
+      const r = validateSettingsPatch({
+        quietHours: { ...baseQh, from: '9:30' }
+      })
+      expect(r?.quietHours?.from).toBe('9:30')
+    })
+
+    it('dedupes days array', () => {
+      const r = validateSettingsPatch({
+        quietHours: { ...baseQh, days: [1, 2, 2, 3, 1] }
+      })
+      expect(r?.quietHours?.days).toEqual([1, 2, 3])
+    })
+
+    it('rejects out-of-range day (7)', () => {
+      expect(
+        validateSettingsPatch({ quietHours: { ...baseQh, days: [0, 7] } })
+      ).toBeNull()
+    })
+
+    it('rejects negative day', () => {
+      expect(
+        validateSettingsPatch({ quietHours: { ...baseQh, days: [-1] } })
+      ).toBeNull()
+    })
+
+    it('rejects non-array days', () => {
+      expect(
+        validateSettingsPatch({ quietHours: { ...baseQh, days: 'all' } })
+      ).toBeNull()
+    })
+
+    it('accepts empty days array (window effectively disabled)', () => {
+      const r = validateSettingsPatch({
+        quietHours: { ...baseQh, days: [] }
+      })
+      expect(r?.quietHours?.days).toEqual([])
+    })
+  })
+})
+
+describe('validateId', () => {
+  it('accepts reasonable id strings', () => {
+    expect(validateId('abc')).toBe('abc')
+    expect(validateId('uuid-v4-style-thing-123')).toBe('uuid-v4-style-thing-123')
+  })
+
+  it('rejects non-strings', () => {
+    expect(validateId(42)).toBeNull()
+    expect(validateId(null)).toBeNull()
+    expect(validateId(undefined)).toBeNull()
+    expect(validateId({})).toBeNull()
+  })
+
+  it('rejects empty string', () => {
+    expect(validateId('')).toBeNull()
+  })
+
+  it('rejects strings longer than 64 chars', () => {
+    expect(validateId('x'.repeat(65))).toBeNull()
+  })
+})
+
+describe('validateActualReps', () => {
+  it('returns undefined for undefined/null (means: use planned reps)', () => {
+    expect(validateActualReps(undefined)).toBeUndefined()
+    expect(validateActualReps(null)).toBeUndefined()
+  })
+
+  it('accepts zero (partial completion = "did 0 of 10")', () => {
+    expect(validateActualReps(0)).toBe(0)
+  })
+
+  it('accepts large values up to cap', () => {
+    expect(validateActualReps(100_000)).toBe(100_000)
+  })
+
+  it('rejects negative', () => {
+    expect(validateActualReps(-1)).toBeUndefined()
+  })
+
+  it('rejects values above cap', () => {
+    expect(validateActualReps(100_001)).toBeUndefined()
+  })
+
+  it('rejects NaN/Infinity', () => {
+    expect(validateActualReps(NaN)).toBeUndefined()
+    expect(validateActualReps(Infinity)).toBeUndefined()
+  })
+})
+
+describe('validateSnoozeMinutes', () => {
+  it('accepts valid minutes', () => {
+    expect(validateSnoozeMinutes(15)).toBe(15)
+    expect(validateSnoozeMinutes(1)).toBe(1)
+    expect(validateSnoozeMinutes(1440)).toBe(1440)
+  })
+
+  it('rejects 0 and above 24h', () => {
+    expect(validateSnoozeMinutes(0)).toBeNull()
+    expect(validateSnoozeMinutes(1441)).toBeNull()
+  })
+
+  it('rejects non-numbers', () => {
+    expect(validateSnoozeMinutes('15')).toBeNull()
+    expect(validateSnoozeMinutes(null)).toBeNull()
+  })
+})

src/main/validate.ts

@@ -18,7 +18,8 @@ import type {
   Settings,
   Theme,
   Language,
-  NotificationMode
+  NotificationMode,
+  ReminderCategory
 } from '@shared/types'
 
 const MAX_STR_LEN = 200
@@ -33,6 +34,12 @@ const VALID_STATS: GameStat[] = [
   'denies',
   'duration_min'
 ]
+const VALID_CATEGORIES: ReminderCategory[] = [
+  'exercise',
+  'hydration',
+  'eyes',
+  'posture'
+]
 const HHMM_RE = /^\d{1,2}:\d{2}$/
 
 function isObj(v: unknown): v is Record<string, unknown> {
@@ -84,6 +91,17 @@ export function validateExerciseInput(
   const intervalMinutes = intInRange(raw.intervalMinutes, 1, 24 * 60)
   const icon = safeStr(raw.icon, 64) ?? 'Activity'
   const enabled = bool(raw.enabled) ?? true
+  const category = oneOf(raw.category, VALID_CATEGORIES) // undefined OK = default
+  const dailyGoal =
+    raw.dailyGoal === undefined || raw.dailyGoal === null
+      ? undefined
+      : intInRange(raw.dailyGoal, 1, 100_000)
+  // dailyGoal: undefined = не задан (нет soft-cap'a), null от UI приводим к
+  // undefined; иначе — должен пройти int-range, иначе reject (нельзя
+  // отправить из renderer'а NaN/негатив и тихо обнулить).
+  if (raw.dailyGoal !== undefined && raw.dailyGoal !== null && dailyGoal === undefined) {
+    return null
+  }
   if (
     name === undefined ||
     reps === undefined ||
@@ -91,7 +109,18 @@ export function validateExerciseInput(
   ) {
     return null
   }
-  return { name, reps, intervalMinutes, icon, enabled }
+  const out: Omit<Exercise, 'id' | 'nextFireAt' | 'lastDoneAt'> = {
+    name,
+    reps,
+    intervalMinutes,
+    icon,
+    enabled
+  }
+  if (category !== undefined) out.category = category
+  if (dailyGoal !== undefined) out.dailyGoal = dailyGoal
+  const adaptive = bool(raw.adaptive)
+  if (adaptive !== undefined) out.adaptive = adaptive
+  return out
 }
 
 export function validateExercisePatch(
@@ -124,6 +153,26 @@ export function validateExercisePatch(
     if (v === undefined) return null
     out.enabled = v
   }
+  if ('category' in raw) {
+    const v = oneOf(raw.category, VALID_CATEGORIES)
+    if (v === undefined) return null
+    out.category = v
+  }
+  if ('dailyGoal' in raw) {
+    // Допустим null/undefined как «снять goal».
+    if (raw.dailyGoal === null || raw.dailyGoal === undefined) {
+      out.dailyGoal = undefined
+    } else {
+      const v = intInRange(raw.dailyGoal, 1, 100_000)
+      if (v === undefined) return null
+      out.dailyGoal = v
+    }
+  }
+  if ('adaptive' in raw) {
+    const v = bool(raw.adaptive)
+    if (v === undefined) return null
+    out.adaptive = v
+  }
   // Allow scheduler-controlled fields to be patched (used by store.markDone
   // through this same boundary), but range-check them.
   if ('nextFireAt' in raw) {
@@ -244,6 +293,27 @@ export function validateSettingsPatch(raw: unknown): Partial<Settings> | null {
     if (v === undefined) return null
     out.soundEnabled = v
   }
+  if ('voicePromptsEnabled' in raw) {
+    const v = bool(raw.voicePromptsEnabled)
+    if (v === undefined) return null
+    out.voicePromptsEnabled = v
+  }
+  if ('meetingAutoPause' in raw) {
+    const v = bool(raw.meetingAutoPause)
+    if (v === undefined) return null
+    out.meetingAutoPause = v
+  }
+  if ('lastSeenVersion' in raw) {
+    // Принимаем строку 0.0.0 .. 999.999.999 (semver-light) или null/undefined
+    // для сброса.
+    if (raw.lastSeenVersion === null || raw.lastSeenVersion === undefined) {
+      out.lastSeenVersion = undefined
+    } else {
+      const v = safeStr(raw.lastSeenVersion, 32)
+      if (v === undefined || !/^\d+\.\d+\.\d+(-[\w.]+)?$/.test(v)) return null
+      out.lastSeenVersion = v
+    }
+  }
   if ('notificationMode' in raw) {
     const v = oneOf(raw.notificationMode, VALID_NOTIFY)
     if (v === undefined) return null

src/main/windows.ts

@@ -1,4 +1,5 @@
 import { BrowserWindow, shell, screen, app, nativeImage } from 'electron'
+import { IPC } from '../shared/ipc'
 import { existsSync } from 'node:fs'
 import { join } from 'node:path'
 
@@ -90,8 +91,13 @@ export function createMainWindow(showImmediately = true): BrowserWindow {
   const win = new BrowserWindow({
     width: 1100,
     height: 720,
-    minWidth: 900,
+    // Минимум подобран так, чтобы:
-    minHeight: 600,
+    // - срабатывал Tailwind `lg:` (≥1024px) → 4 hero-stat в один ряд, а не 2×2
+    // - сайдбар (256px) + контент (max-w-5xl, padding lg:px-10) помещались без
+    //   горизонтального скролла heatmap'а и карточек упражнений
+    // - по вертикали оставался запас на header + stats + heatmap без обрезки
+    minWidth: 1100,
+    minHeight: 700,
     show: false,
     frame: false,
     backgroundColor: '#0f1117',
@@ -100,7 +106,12 @@ export function createMainWindow(showImmediately = true): BrowserWindow {
     ...(icon ? { icon } : {}),
     webPreferences: {
       preload: preloadPath(),
-      sandbox: false,
+      // sandbox: true — preload использует только contextBridge + ipcRenderer
+      // (оба sandbox-safe), никаких Node-built-ins (fs/path/child_process).
+      // Sandbox изолирует renderer от Chromium GPU/IPC процессов на уровне
+      // OS-сэндбокса; даже RCE через зависимости renderer'а не получит
+      // полного Node-доступа из preload.
+      sandbox: true,
       contextIsolation: true,
       nodeIntegration: false
     }
@@ -110,6 +121,16 @@ export function createMainWindow(showImmediately = true): BrowserWindow {
     if (showImmediately) win.show()
   })
 
+  // Сообщаем рендереру об изменении max-состояния, чтобы он мог менять
+  // иконку (квадрат ↔ «двойной квадрат») в кастомном тайтлбаре.
+  const emitMaxState = (maximized: boolean): void => {
+    if (!win.isDestroyed()) {
+      win.webContents.send(IPC.evtMaximizeChanged, maximized)
+    }
+  }
+  win.on('maximize', () => emitMaxState(true))
+  win.on('unmaximize', () => emitMaxState(false))
+
   installSafeNavigation(win)
 
   loadRoute(win, 'main')
@@ -155,7 +176,7 @@ export function createReminderWindow(): BrowserWindow {
     ...(icon ? { icon } : {}),
     webPreferences: {
       preload: preloadPath(),
-      sandbox: false,
+      sandbox: true, // см. createMainWindow — preload не использует Node.
       contextIsolation: true,
       nodeIntegration: false
     }

src/preload/index.ts

@@ -47,6 +47,9 @@ const api = {
   getAccentColor: (): Promise<string> => ipcRenderer.invoke(IPC.getAccentColor),
   getOsTheme: (): Promise<'light' | 'dark'> =>
     ipcRenderer.invoke(IPC.getOsTheme),
+  getAppVersion: (): Promise<string> => ipcRenderer.invoke(IPC.getAppVersion),
+  getMeetingActive: (): Promise<boolean> =>
+    ipcRenderer.invoke(IPC.getMeetingActive),
 
   pauseAll: (): Promise<void> => ipcRenderer.invoke(IPC.pauseAll),
   resumeAll: (): Promise<void> => ipcRenderer.invoke(IPC.resumeAll),
@@ -54,6 +57,9 @@ const api = {
   reminderClose: (): Promise<void> => ipcRenderer.invoke(IPC.reminderClose),
 
   minimizeMain: (): void => ipcRenderer.send(IPC.minimizeMain),
+  toggleMaximizeMain: (): void => ipcRenderer.send(IPC.toggleMaximizeMain),
+  isMaximizedMain: (): Promise<boolean> =>
+    ipcRenderer.invoke(IPC.isMaximizedMain),
   closeMain: (): void => ipcRenderer.send(IPC.closeMain),
   hideMain: (): void => ipcRenderer.send(IPC.hideMain),
 
@@ -79,6 +85,8 @@ const api = {
     ipcRenderer.invoke(IPC.deleteChallenge, id),
   toggleChallenge: (id: string, enabled: boolean): Promise<Challenge> =>
     ipcRenderer.invoke(IPC.toggleChallenge, id, enabled),
+  markChallengeDone: (id: string, reps: number): Promise<boolean> =>
+    ipcRenderer.invoke(IPC.markChallengeDone, id, reps),
 
   closeMatchSummary: (): Promise<void> =>
     ipcRenderer.invoke(IPC.closeMatchSummary),
@@ -93,7 +101,7 @@ const api = {
           id: GameId,
           stats: Record<string, number>
         ): Promise<void> =>
-          ipcRenderer.invoke('dev:simulateMatchEnd', id, stats)
+          ipcRenderer.invoke(IPC.devSimulateMatchEnd, id, stats)
       }
     : {}),
 
@@ -102,8 +110,10 @@ const api = {
     ipcRenderer.invoke(IPC.updaterStatus),
   updaterCheck: (): Promise<UpdaterStatus> =>
     ipcRenderer.invoke(IPC.updaterCheck),
-  updaterDownload: (): Promise<void> => ipcRenderer.invoke(IPC.updaterDownload),
+  // Fire-and-forget. Прогресс и завершение прилетают через onUpdaterStatus —
-  updaterInstall: (): Promise<void> => ipcRenderer.invoke(IPC.updaterInstall),
+  // renderer не должен `await`'ить, иначе busy-state висит весь download.
+  updaterDownload: (): void => ipcRenderer.send(IPC.updaterDownload),
+  updaterInstall: (): void => ipcRenderer.send(IPC.updaterInstall),
 
   // History
   getHistory: (sinceMs?: number): Promise<HistoryEntry[]> =>
@@ -111,6 +121,19 @@ const api = {
   clearHistory: (beforeTs?: number): Promise<number> =>
     ipcRenderer.invoke(IPC.clearHistory, beforeTs),
 
+  // Export / Import — открывают native save/open dialogs из main process.
+  exportState: (): Promise<{
+    ok: boolean
+    canceled: boolean
+    path: string | null
+    error?: string
+  }> => ipcRenderer.invoke(IPC.exportState),
+  importState: (): Promise<{
+    ok: boolean
+    canceled: boolean
+    error?: string
+  }> => ipcRenderer.invoke(IPC.importState),
+
   onTick: (h: Handler<Tick[]>): Unsub => on(IPC.evtTick, h),
   onFire: (h: Handler<Exercise>): Unsub => on(IPC.evtFire, h),
   onMatchEnd: (h: Handler<MatchSummary>): Unsub => on(IPC.evtMatchEnd, h),
@@ -121,7 +144,13 @@ const api = {
   onGamesChanged: (h: Handler<GameStatus[]>): Unsub =>
     on(IPC.evtGamesChanged, h),
   onUpdaterStatus: (h: Handler<UpdaterStatus>): Unsub =>
-    on(IPC.evtUpdaterStatus, h)
+    on(IPC.evtUpdaterStatus, h),
+  onMaximizeChanged: (h: Handler<boolean>): Unsub =>
+    on(IPC.evtMaximizeChanged, h),
+  onMeetingChanged: (h: Handler<boolean>): Unsub =>
+    on(IPC.evtMeetingChanged, h),
+  onHistoryChanged: (h: Handler<void>): Unsub =>
+    on(IPC.evtHistoryChanged, h)
 }
 
 contextBridge.exposeInMainWorld('api', api)

src/renderer/index.html

@@ -3,11 +3,14 @@
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <meta http-equiv="Content-Security-Policy" content="default-src 'self'; style-src 'self' 'unsafe-inline' https://fonts.googleapis.com; font-src 'self' https://fonts.gstatic.com; img-src 'self' data:; script-src 'self'" />
+    <!--
+      CSP: всё локально, без внешних origins. Шрифты подгружаются через
+      @fontsource/* импорты в globals.css. style-src 'unsafe-inline' нужен
+      для Tailwind utility-классов и инлайн-стилей framer-motion. font-src
+      включает data: на случай если кто-то вставит base64 SVG-glyph.
+    -->
+    <meta http-equiv="Content-Security-Policy" content="default-src 'self'; style-src 'self' 'unsafe-inline'; font-src 'self' data:; img-src 'self' data:; script-src 'self'; connect-src 'self'; base-uri 'self'; frame-ancestors 'none'" />
     <title>Exercise Reminder</title>
-    <link rel="preconnect" href="https://fonts.googleapis.com" />
-    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
-    <link href="https://fonts.googleapis.com/css2?family=Plus+Jakarta+Sans:wght@400;500;600;700;800&family=Bricolage+Grotesque:opsz,wght@12..96,500;12..96,600;12..96,700;12..96,800&family=JetBrains+Mono:wght@400;500;600;700&display=swap" rel="stylesheet" />
   </head>
   <body>
     <div id="root"></div>

src/renderer/src/App.tsx

@@ -4,6 +4,9 @@ import { AnimatePresence, motion } from 'framer-motion'
 import { Sidebar } from './components/Sidebar'
 import { Titlebar } from './components/Titlebar'
 import { ErrorBoundary } from './components/ErrorBoundary'
+import { WhatsNewModal } from './components/WhatsNewModal'
+import { Skeleton } from './components/ui/Skeleton'
+import { unseenVersions } from '@shared/release-notes'
 import Dashboard from './pages/Dashboard'
 import Exercises from './pages/Exercises'
 import GamesPage from './pages/Games'
@@ -17,7 +20,12 @@ let backendSubscribed = false
 
 export default function App(): JSX.Element {
   const hydrated = useAppStore((s) => s.hydrated)
+  const settings = useAppStore((s) => s.state?.settings)
   const [mobileNavOpen, setMobileNavOpen] = useState(false)
+  const [whatsNew, setWhatsNew] = useState<{
+    open: boolean
+    versions: string[]
+  }>({ open: false, versions: [] })
 
   useEffect(() => {
     if (backendSubscribed) return undefined
@@ -29,6 +37,54 @@ export default function App(): JSX.Element {
     }
   }, [])
 
+  // Различаем три кейса по `lastSeenVersion`:
+  //   1) есть и !== current → классический update path, показываем
+  //      пропущенные заметки.
+  //   2) есть и === current → ничего не делаем.
+  //   3) нет (undefined) → это ИЛИ первый запуск нового пользователя,
+  //      ИЛИ существующий пользователь, который апгрейдится с версии,
+  //      где поля ещё не было (всё < 0.5.6).
+  //      Разрешаем эту неоднозначность через proxy «уже пользовался
+  //      приложением» — хотя бы одно упражнение имеет `lastDoneAt`.
+  //      Новичкам тихо записываем; обновляющимся — показываем заметки
+  //      текущей версии, чтобы они узнали про новые фичи.
+  useEffect(() => {
+    if (!hydrated || !settings) return
+    const exercises = useAppStore.getState().state?.exercises ?? []
+    const isExistingUser = exercises.some((e) => e.lastDoneAt !== undefined)
+    void window.api.getAppVersion().then((current) => {
+      const last = settings.lastSeenVersion
+      if (!last) {
+        if (isExistingUser) {
+          // Обновляющийся — показываем заметки текущей версии.
+          setWhatsNew({ open: true, versions: [current] })
+        } else {
+          // Новый — тихо записываем, не отвлекаем.
+          window.api.updateSettings({ lastSeenVersion: current })
+        }
+        return
+      }
+      if (last !== current) {
+        const versions = unseenVersions(current, last)
+        if (versions.length > 0) {
+          setWhatsNew({ open: true, versions })
+        } else {
+          window.api.updateSettings({ lastSeenVersion: current })
+        }
+      }
+    })
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [hydrated])
+
+  function closeWhatsNew(): void {
+    setWhatsNew({ open: false, versions: [] })
+    // Записываем «видел» только после закрытия — если пользователь убил
+    // окно процессом до клика, при следующем запуске покажется снова.
+    void window.api.getAppVersion().then((current) => {
+      window.api.updateSettings({ lastSeenVersion: current })
+    })
+  }
+
   return (
     <ErrorBoundary>
       <HashRouter>
@@ -45,11 +101,31 @@ export default function App(): JSX.Element {
                   <RoutedPages onNav={() => setMobileNavOpen(false)} />
                 </ErrorBoundary>
               ) : (
-                // Neutral placeholder — settings (and lang) aren't loaded yet.
+                // Skeleton на время гидрации — settings (и язык) ещё не
-                <div className="p-8 text-text/45" />
+                // загружены, текст показывать рано, но пустота выглядит как
+                // зависание. Каркас задаёт ожидание «сейчас появится контент».
+                <div
+                  className="p-6 sm:p-8 space-y-5 max-w-3xl"
+                  role="status"
+                  aria-label="Loading"
+                >
+                  <Skeleton className="h-9 w-48" />
+                  <div className="grid grid-cols-1 sm:grid-cols-3 gap-4">
+                    <Skeleton className="h-24" />
+                    <Skeleton className="h-24" />
+                    <Skeleton className="h-24" />
+                  </div>
+                  <Skeleton className="h-40" />
+                  <Skeleton className="h-28" />
+                </div>
               )}
             </main>
           </div>
+          <WhatsNewModal
+            open={whatsNew.open}
+            versions={whatsNew.versions}
+            onClose={closeWhatsNew}
+          />
         </div>
       </HashRouter>
     </ErrorBoundary>

src/renderer/src/ReminderApp.tsx

@@ -20,6 +20,7 @@ import type {
 import { statLabel } from '@shared/types'
 import { Icon } from './lib/icon'
 import { formatInterval } from './lib/format'
+import { speak } from './lib/tts'
 import { translate, translateN } from './i18n'
 
 type Mode =
@@ -27,10 +28,21 @@ type Mode =
   | { kind: 'exercise'; exercise: Exercise }
   | { kind: 'match'; summary: MatchSummary; done: Set<string> }
 
+/** Минимальный нативный confirm. В reminder-окне нет места для модалки,
+ * проще использовать встроенный диалог. */
+function nativeConfirm(message: string): boolean {
+  // eslint-disable-next-line no-alert -- reminder window не имеет своей Modal-обвязки
+  return window.confirm(message)
+}
+
 export default function ReminderApp(): JSX.Element {
   const [mode, setMode] = useState<Mode>({ kind: 'idle' })
   const [settings, setSettings] = useState<Settings | null>(null)
   const settingsRef = useRef<Settings | null>(null)
+  // ChallengeId'ы, для которых уже отправили markChallengeDone IPC. ref,
+  // не state — нужен только для дедупа rapid double-click. Сбрасывается
+  // когда приходит новый match summary (см. onMatchEnd ниже).
+  const sentChallengesRef = useRef<Set<string>>(new Set())
 
   useEffect(() => {
     settingsRef.current = settings
@@ -41,11 +53,37 @@ export default function ReminderApp(): JSX.Element {
     const u0 = window.api.onStateChanged((s) => setSettings(s.settings))
     const u1 = window.api.onFire((ex) => {
       setMode({ kind: 'exercise', exercise: ex })
-      if (settingsRef.current?.soundEnabled) playBeep()
+      const s = settingsRef.current
+      if (s?.soundEnabled) playBeep()
+      if (s?.voicePromptsEnabled) {
+        // Задержка 800ms даёт пользователю шанс decrement'нуть stepper до
+        // фактического количества — TTS прозвучит уже под реальную цифру,
+        // если успел нажать -. Иначе скажет планируемые reps.
+        const lang = s.language ?? 'ru'
+        setTimeout(() => {
+          const phrase =
+            lang === 'ru'
+              ? `${ex.name}. ${ex.reps} ${repWordRu(ex.reps)}`
+              : `${ex.name}. ${ex.reps} ${ex.reps === 1 ? 'rep' : 'reps'}`
+          speak(phrase, lang)
+        }, 800)
+      }
     })
     const u2 = window.api.onMatchEnd((summary) => {
+      // Новый матч — сбрасываем дедуп challenge'ей.
+      sentChallengesRef.current = new Set()
       setMode({ kind: 'match', summary, done: new Set() })
-      if (settingsRef.current?.soundEnabled) playBeep()
+      const s = settingsRef.current
+      if (s?.soundEnabled) playBeep()
+      if (s?.voicePromptsEnabled) {
+        const total = summary.results.reduce((acc, r) => acc + r.reps, 0)
+        const lang = s.language ?? 'ru'
+        const phrase =
+          lang === 'ru'
+            ? `Матч завершён. ${total} ${repWordRu(total)} ждут.`
+            : `Match complete. ${total} ${total === 1 ? 'rep' : 'reps'} await.`
+        speak(phrase, lang)
+      }
     })
     return () => {
       u0()
@@ -66,6 +104,27 @@ export default function ReminderApp(): JSX.Element {
   }, [mode.kind])
 
   function close(): void {
+    // Если в Match Summary остались незакрытые челленджи — подтверждаем,
+    // чтобы пользователь не «пролетел» окно по привычке и не потерял
+    // мотивацию (и метрики стрик/today_done).
+    if (mode.kind === 'match') {
+      const remaining = mode.summary.results.filter(
+        (r) => !mode.done.has(r.challengeId)
+      )
+      if (remaining.length > 0) {
+        const lang = settings?.language ?? 'ru'
+        const reps = remaining.reduce((s, r) => s + r.reps, 0)
+        const msg =
+          lang === 'ru'
+            ? `Осталось ${remaining.length} ${
+                remaining.length === 1 ? 'челлендж' : 'челленджей'
+              } · ${reps} повторений. Закрыть окно?`
+            : `${remaining.length} ${
+                remaining.length === 1 ? 'challenge' : 'challenges'
+              } left · ${reps} reps. Close anyway?`
+        if (!nativeConfirm(msg)) return
+      }
+    }
     setMode({ kind: 'idle' })
     window.api.reminderClose()
   }
@@ -91,9 +150,19 @@ export default function ReminderApp(): JSX.Element {
       summary={mode.summary}
       done={mode.done}
       lang={lang}
-      onMarkDone={(id) =>
+      onMarkDone={(id) => {
-        // Functional update so a second rapid click can't race against a stale
+        // Дедупликация: rapid double-click может два раза вызвать
-        // `mode.done` captured in this closure.
+        // onMarkDone до того как `disabled={done}` доедет до DOM.
+        // Раньше это писало в историю дважды → лишние +N reps.
+        if (sentChallengesRef.current.has(id)) return
+        sentChallengesRef.current.add(id)
+        // 1) IPC: записываем в историю (раньше делали только локальный set,
+        //    из-за чего матч-челленджи не считались в стрик/achievements).
+        const result = mode.summary.results.find((r) => r.challengeId === id)
+        if (result && result.reps > 0) {
+          void window.api.markChallengeDone(id, result.reps)
+        }
+        // 2) Functional update: rapid-click race-safe.
         setMode((m) =>
           m.kind === 'match'
             ? {
@@ -103,7 +172,7 @@ export default function ReminderApp(): JSX.Element {
               }
             : m
         )
-      }
+      }}
       onClose={close}
     />
   )
@@ -201,7 +270,7 @@ function ExerciseReminder({
         </motion.div>
 
         <div className="text-[13px] uppercase tracking-[0.18em] text-accent font-bold">
-          {t('reminder.kicker')}
+          {t(`category.${exercise.category ?? 'exercise'}.cta`)}
         </div>
         <h1 className="font-serif text-[30px] leading-tight tracking-tight mt-2 mb-3 font-bold">
           {exercise.name}
@@ -478,6 +547,18 @@ function ChallengeRow({
   )
 }
 
+/**
+ * CLDR-минимум для русского склонения «раз». 1 раз / 2 раза / 5 раз.
+ * Не тащим сюда полную плюрализацию из i18n — это TTS-only фраза.
+ */
+function repWordRu(n: number): string {
+  const m10 = Math.abs(n) % 10
+  const m100 = Math.abs(n) % 100
+  if (m10 === 1 && m100 !== 11) return 'раз'
+  if (m10 >= 2 && m10 <= 4 && (m100 < 10 || m100 >= 20)) return 'раза'
+  return 'раз'
+}
+
 function playBeep(): void {
   try {
     const Ctx =

src/renderer/src/components/AchievementsCard.tsx

@@ -0,0 +1,217 @@
+import { useEffect, useMemo, useState } from 'react'
+import { motion } from 'framer-motion'
+import { Award, Activity, Flame, Sparkles, TrendingUp, Lock } from 'lucide-react'
+import type { Exercise, HistoryEntry } from '@shared/types'
+import {
+  computeAchievements,
+  type AchievementProgress
+} from '../lib/achievements'
+import { useT } from '../i18n'
+import { useAnnounce } from '../lib/useAnnounce'
+
+const CELEBRATED_KEY = 'laude:celebratedAchievements'
+
+function loadCelebrated(): Set<string> {
+  try {
+    const raw = localStorage.getItem(CELEBRATED_KEY)
+    if (!raw) return new Set()
+    const parsed = JSON.parse(raw)
+    return Array.isArray(parsed) ? new Set(parsed) : new Set()
+  } catch {
+    return new Set()
+  }
+}
+
+function saveCelebrated(set: Set<string>): void {
+  try {
+    localStorage.setItem(CELEBRATED_KEY, JSON.stringify(Array.from(set)))
+  } catch {
+    /* localStorage может быть отключён — ничего страшного, просто будет celebrate каждый раз */
+  }
+}
+
+const ICON_BY_NAME = {
+  Activity,
+  Flame,
+  Sparkles,
+  TrendingUp
+} as const
+
+type Props = {
+  history: HistoryEntry[]
+  exercises: Exercise[]
+}
+
+/**
+ * Сетка достижений. Показывает: (1) все unlocked прямо, (2) первое
+ * unlocked-в-прогрессе (ближайшее по %% — мотивация), (3) остальные
+ * как блёклые «locked». В компактной grid 4-в-ряд.
+ */
+export function AchievementsCard({ history, exercises }: Props): JSX.Element {
+  const { t } = useT()
+  const announce = useAnnounce()
+
+  const achievements = useMemo(
+    () => computeAchievements(history, exercises),
+    [history, exercises]
+  )
+
+  // Достижения, которые в этом mount пользователь впервые увидел unlocked
+  // (т.е. не были в localStorage до этого). Для них играем pulse-анимацию.
+  // После анимации помечаем как celebrated, чтобы при следующем рендере
+  // они уже не подпрыгивали.
+  const [freshlyUnlocked, setFreshlyUnlocked] = useState<Set<string>>(
+    () => new Set()
+  )
+  useEffect(() => {
+    const celebrated = loadCelebrated()
+    const fresh = new Set<string>()
+    for (const a of achievements) {
+      if (a.unlocked && !celebrated.has(a.def.id)) {
+        fresh.add(a.def.id)
+        celebrated.add(a.def.id)
+      }
+    }
+    if (fresh.size > 0) {
+      setFreshlyUnlocked(fresh)
+      saveCelebrated(celebrated)
+      // Озвучиваем разблокировку для screen-reader'ов — pulse-анимацию они
+      // не видят.
+      for (const a of achievements) {
+        if (fresh.has(a.def.id)) {
+          announce(t('achievements.announce', { title: t(a.def.titleKey) }))
+        }
+      }
+      // Снимаем «свежесть» через 5 сек чтобы pulse не крутился вечно.
+      const timer = setTimeout(() => setFreshlyUnlocked(new Set()), 5_000)
+      return () => clearTimeout(timer)
+    }
+    return undefined
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [achievements])
+
+  const unlocked = achievements.filter((a) => a.unlocked)
+  const locked = achievements.filter((a) => !a.unlocked)
+  // Сортируем locked по близости к unlock'у — чтобы «осталось 12»
+  // оказалось вверху, а «осталось 9999» внизу.
+  const nearestLocked = [...locked].sort((a, b) => {
+    const ap = a.current / a.target
+    const bp = b.current / b.target
+    return bp - ap
+  })
+
+  // Показываем: все unlocked + first 2 nearest locked (preview-мотивация).
+  const visible = [...unlocked, ...nearestLocked.slice(0, 2)]
+
+  if (visible.length === 0) return <></>
+
+  return (
+    <div className="bg-surface rounded-2xl p-5 shadow-card dark:ring-0.5 dark:ring-hairline/30">
+      <div className="flex items-center justify-between mb-3">
+        <div className="flex items-center gap-2">
+          <div className="w-7 h-7 rounded-lg bg-accent text-white grid place-items-center">
+            <Award size={14} strokeWidth={2.6} />
+          </div>
+          <div className="text-[14px] text-text/75 font-semibold">
+            {t('achievements.title')}
+          </div>
+        </div>
+        <div className="text-[12px] text-text/55 font-mono-num font-medium">
+          {t('achievements.unlocked_of', {
+            n: unlocked.length,
+            total: achievements.length
+          })}
+        </div>
+      </div>
+      <div className="grid grid-cols-2 sm:grid-cols-3 md:grid-cols-4 gap-2">
+        {visible.map((a) => (
+          <Badge
+            key={a.def.id}
+            a={a}
+            fresh={freshlyUnlocked.has(a.def.id)}
+          />
+        ))}
+      </div>
+    </div>
+  )
+}
+
+function Badge({
+  a,
+  fresh
+}: {
+  a: AchievementProgress
+  fresh: boolean
+}): JSX.Element {
+  const { t } = useT()
+  const IconCmp = ICON_BY_NAME[a.def.icon as keyof typeof ICON_BY_NAME] ?? Award
+  const pct = Math.min(100, Math.round((a.current / a.target) * 100))
+  const toneBg = {
+    accent: 'bg-accent',
+    warning: 'bg-warning',
+    success: 'bg-success',
+    info: 'bg-info'
+  }[a.def.tone]
+
+  return (
+    <motion.div
+      animate={
+        fresh
+          ? {
+              scale: [1, 1.08, 1],
+              boxShadow: [
+                '0 0 0 0 rgb(var(--accent) / 0)',
+                '0 0 0 6px rgb(var(--accent) / 0.4)',
+                '0 0 0 0 rgb(var(--accent) / 0)'
+              ]
+            }
+          : {}
+      }
+      transition={
+        fresh
+          ? {
+              duration: 1.4,
+              repeat: 2,
+              ease: 'easeInOut'
+            }
+          : {}
+      }
+      className={[
+        'rounded-xl p-2.5 transition-opacity',
+        a.unlocked ? 'bg-surface-2' : 'bg-surface-2 opacity-55'
+      ].join(' ')}
+      title={t(a.def.descKey, { target: a.target })}
+    >
+      <div className="flex items-center gap-2 mb-1.5">
+        <div
+          className={[
+            'w-7 h-7 rounded-lg grid place-items-center text-white shrink-0',
+            a.unlocked ? toneBg : 'bg-text/30'
+          ].join(' ')}
+        >
+          {a.unlocked ? (
+            <IconCmp size={14} strokeWidth={2.4} />
+          ) : (
+            <Lock size={12} strokeWidth={2.4} />
+          )}
+        </div>
+        <div className="text-[12px] font-semibold truncate">
+          {t(a.def.titleKey)}
+        </div>
+      </div>
+      {!a.unlocked && (
+        <>
+          <div className="h-1 rounded-full bg-text/10 overflow-hidden">
+            <div
+              className={['h-full', toneBg].join(' ')}
+              style={{ width: `${pct}%` }}
+            />
+          </div>
+          <div className="text-[10px] text-text/55 mt-1 font-mono-num font-medium">
+            {t('achievements.progress', { n: a.target - a.current })}
+          </div>
+        </>
+      )}
+    </motion.div>
+  )
+}

src/renderer/src/components/ExerciseCard.tsx

@@ -1,15 +1,18 @@
 import { motion } from 'framer-motion'
-import { Check, MoreHorizontal } from 'lucide-react'
+import { Check, MoreHorizontal, Brain, CheckCircle2 } from 'lucide-react'
-import { useState } from 'react'
+import { useEffect, useRef, useState } from 'react'
 import type { Exercise, Tick } from '@shared/types'
 import { Icon } from '../lib/icon'
 import { formatCountdown } from '../lib/format'
 import { Switch } from './ui/Switch'
 import { useT } from '../i18n'
+import { useAnnounce } from '../lib/useAnnounce'
 
 type Props = {
   exercise: Exercise
   tick?: Tick
+  /** Сделано повторений сегодня (для daily-goal индикатора). */
+  doneToday?: number
   onEdit: () => void
   onDelete: () => void
   onToggle: (enabled: boolean) => void
@@ -24,6 +27,7 @@ type Props = {
 export function ExerciseCard({
   exercise,
   tick,
+  doneToday,
   onEdit,
   onDelete,
   onToggle,
@@ -33,9 +37,71 @@ export function ExerciseCard({
   const total = exercise.intervalMinutes * 60_000
   const remaining = Math.max(0, Math.min(total, ms))
   const elapsedPct = total > 0 ? 1 - remaining / total : 0
-  const isDue = ms <= 0 && exercise.enabled
+  const goalReached =
+    exercise.dailyGoal !== undefined &&
+    exercise.dailyGoal > 0 &&
+    (doneToday ?? 0) >= exercise.dailyGoal
+  // Если цель закрыта — упражнение «отдыхает» до завтра, isDue не считаем.
+  const isDue = ms <= 0 && exercise.enabled && !goalReached
   const [menuOpen, setMenuOpen] = useState(false)
+  const triggerRef = useRef<HTMLButtonElement>(null)
+  const menuRef = useRef<HTMLDivElement>(null)
+
+  // При открытии меню переводим фокус на первый пункт — клавиатурный
+  // пользователь сразу внутри, без слепого Tab'а.
+  useEffect(() => {
+    if (!menuOpen) return
+    menuRef.current
+      ?.querySelector<HTMLButtonElement>('[role="menuitem"]')
+      ?.focus()
+  }, [menuOpen])
+
+  // Esc закрывает и возвращает фокус на триггер; стрелки/Home/End — навигация.
+  const onMenuKeyDown = (e: React.KeyboardEvent<HTMLDivElement>): void => {
+    const items = Array.from(
+      menuRef.current?.querySelectorAll<HTMLButtonElement>(
+        '[role="menuitem"]'
+      ) ?? []
+    )
+    if (items.length === 0) return
+    const idx = items.indexOf(document.activeElement as HTMLButtonElement)
+    if (e.key === 'Escape') {
+      e.preventDefault()
+      setMenuOpen(false)
+      triggerRef.current?.focus()
+    } else if (e.key === 'ArrowDown') {
+      e.preventDefault()
+      items[(idx + 1) % items.length]?.focus()
+    } else if (e.key === 'ArrowUp') {
+      e.preventDefault()
+      items[(idx - 1 + items.length) % items.length]?.focus()
+    } else if (e.key === 'Home') {
+      e.preventDefault()
+      items[0]?.focus()
+    } else if (e.key === 'End') {
+      e.preventDefault()
+      items[items.length - 1]?.focus()
+    }
+  }
+  // Дедуп rapid double-click на «Готово». Между кликом и обновлением
+  // nextFireAt (через broadcastState) есть окно ~1 сек, в которое можно
+  // вызвать markDone повторно и записать лишний entry в историю.
+  const markDoneInFlightRef = useRef(false)
   const { t, lang } = useT()
+  const announce = useAnnounce()
+  const handleMarkDone = (): void => {
+    if (markDoneInFlightRef.current) return
+    markDoneInFlightRef.current = true
+    onMarkDone()
+    // Озвучиваем для screen-reader'ов — кнопка после засчёта исчезает,
+    // визуальный feedback незрячему недоступен.
+    announce(`${t('btn.done')}: ${exercise.name}`)
+    // К моменту окончания таймаута isDue уже false (после store-tick), кнопка
+    // не рендерится — флаг чистим на всякий случай для будущих кейсов.
+    setTimeout(() => {
+      markDoneInFlightRef.current = false
+    }, 1000)
+  }
 
   // Ring math
   const R = 22
@@ -102,9 +168,12 @@ export function ExerciseCard({
             </h3>
             <div className="relative">
               <button
+                ref={triggerRef}
                 onClick={() => setMenuOpen((v) => !v)}
                 className="w-7 h-7 grid place-items-center rounded-full text-text/45 hover:bg-surface-2 active:scale-90 transition-all"
                 aria-label={t('titlebar.menu_aria')}
+                aria-haspopup="menu"
+                aria-expanded={menuOpen}
               >
                 <MoreHorizontal size={16} />
               </button>
@@ -114,8 +183,15 @@ export function ExerciseCard({
                     className="fixed inset-0 z-10"
                     onClick={() => setMenuOpen(false)}
                   />
-                  <div className="absolute right-0 top-8 z-20 min-w-[140px] bg-surface rounded-xl shadow-sheet ring-0.5 ring-hairline/30 py-1 overflow-hidden">
+                  <div
+                    ref={menuRef}
+                    role="menu"
+                    aria-label={exercise.name}
+                    onKeyDown={onMenuKeyDown}
+                    className="absolute right-0 top-8 z-20 min-w-[140px] bg-surface rounded-xl shadow-sheet ring-0.5 ring-hairline/30 py-1 overflow-hidden"
+                  >
                     <button
+                      role="menuitem"
                       onClick={() => {
                         setMenuOpen(false)
                         onEdit()
@@ -125,6 +201,7 @@ export function ExerciseCard({
                       {t('btn.edit')}
                     </button>
                     <button
+                      role="menuitem"
                       onClick={() => {
                         setMenuOpen(false)
                         onDelete()
@@ -148,16 +225,48 @@ export function ExerciseCard({
           {/* Countdown + switch */}
           <div className="flex items-end justify-between mt-3.5">
             <div>
-              <div className="text-[12px] text-text/60 uppercase tracking-wider font-semibold">
+              <div className="text-[12px] text-text/60 uppercase tracking-wider font-semibold inline-flex items-center gap-1">
-                {isDue ? t('dashboard.stat.next.now') : t('fmt.through')}
+                {goalReached ? (
+                  <>
+                    <CheckCircle2
+                      size={11}
+                      strokeWidth={2.5}
+                      className="text-success"
+                    />
+                    {t('exercise.goal_reached.kicker')}
+                  </>
+                ) : isDue ? (
+                  t('dashboard.stat.next.now')
+                ) : (
+                  t('fmt.through')
+                )}
+                {exercise.adaptive && !goalReached && (
+                  <Brain
+                    size={11}
+                    strokeWidth={2.5}
+                    className="text-info ml-0.5"
+                    aria-label={t('exercise.adaptive.badge')}
+                  />
+                )}
               </div>
               <div
                 className={[
                   'font-mono-num text-[24px] font-bold leading-none mt-1 tracking-tight',
-                  isDue ? 'text-accent' : 'text-text'
+                  goalReached
+                    ? 'text-success'
+                    : isDue
+                      ? 'text-accent'
+                      : 'text-text'
                 ].join(' ')}
               >
-                {exercise.enabled ? formatCountdown(ms, lang) : t('fmt.paused')}
+                {!exercise.enabled
+                  ? t('fmt.paused')
+                  : goalReached
+                    ? t('exercise.goal_reached.value', {
+                        done: doneToday ?? 0,
+                        goal: exercise.dailyGoal ?? 0
+                      })
+                    : formatCountdown(ms, lang)}
               </div>
             </div>
             <Switch
@@ -173,7 +282,7 @@ export function ExerciseCard({
         <motion.button
           initial={{ opacity: 0, y: 4 }}
           animate={{ opacity: 1, y: 0 }}
-          onClick={onMarkDone}
+          onClick={handleMarkDone}
           className="mt-4 w-full h-11 rounded-xl bg-accent text-white text-[15px] font-bold inline-flex items-center justify-center gap-1.5 active:scale-[0.98] transition-transform"
         >
           <Check size={15} strokeWidth={2.5} /> {t('btn.done')}

src/renderer/src/components/ExerciseEditor.tsx

@@ -1,5 +1,6 @@
 import { useEffect, useState } from 'react'
-import type { Exercise } from '@shared/types'
+import type { Exercise, ReminderCategory } from '@shared/types'
+import { REMINDER_CATEGORIES } from '@shared/types'
 import { Modal } from './ui/Modal'
 import { Button } from './ui/Button'
 import { ICON_CHOICES, Icon } from '../lib/icon'
@@ -11,6 +12,10 @@ type Draft = {
   icon: string
   intervalMinutes: number
   enabled: boolean
+  category: ReminderCategory
+  /** undefined = без дневной цели (только interval). */
+  dailyGoal?: number
+  adaptive?: boolean
 }
 
 const EMPTY: Draft = {
@@ -18,7 +23,10 @@ const EMPTY: Draft = {
   reps: 10,
   icon: 'Activity',
   intervalMinutes: 30,
-  enabled: true
+  enabled: true,
+  category: 'exercise',
+  dailyGoal: undefined,
+  adaptive: false
 }
 
 type Props = {
@@ -44,7 +52,10 @@ export function ExerciseEditor({
         reps: exercise.reps,
         icon: exercise.icon,
         intervalMinutes: exercise.intervalMinutes,
-        enabled: exercise.enabled
+        enabled: exercise.enabled,
+        category: exercise.category ?? 'exercise',
+        dailyGoal: exercise.dailyGoal,
+        adaptive: exercise.adaptive ?? false
       })
     } else {
       setDraft(EMPTY)
@@ -101,6 +112,26 @@ export function ExerciseEditor({
           />
         </Field>
 
+        <Field label={t('editor.field.category')}>
+          <div className="grid grid-cols-4 gap-2">
+            {REMINDER_CATEGORIES.map((c) => (
+              <button
+                key={c}
+                type="button"
+                onClick={() => setDraft({ ...draft, category: c })}
+                className={[
+                  'h-10 px-2 rounded-xl text-[13px] font-semibold transition-all active:scale-95 truncate',
+                  draft.category === c
+                    ? 'bg-accent text-white'
+                    : 'bg-surface-2 text-text/65 hover:text-text'
+                ].join(' ')}
+              >
+                {t(`category.${c}`)}
+              </button>
+            ))}
+          </div>
+        </Field>
+
         <div className="grid grid-cols-2 gap-3">
           <Field label={t('editor.field.reps')}>
             <input
@@ -132,6 +163,58 @@ export function ExerciseEditor({
           </Field>
         </div>
 
+        <Field label={t('editor.field.daily_goal')}>
+          <div className="flex items-center gap-2">
+            <input
+              type="number"
+              min={1}
+              placeholder={t('editor.field.daily_goal.placeholder')}
+              value={draft.dailyGoal ?? ''}
+              onChange={(e) => {
+                const v = e.target.value
+                if (v === '') setDraft({ ...draft, dailyGoal: undefined })
+                else
+                  setDraft({
+                    ...draft,
+                    dailyGoal: Math.max(1, Number(v) || 1)
+                  })
+              }}
+              className="ios-input font-mono-num flex-1"
+            />
+            {draft.dailyGoal !== undefined && (
+              <button
+                type="button"
+                onClick={() => setDraft({ ...draft, dailyGoal: undefined })}
+                className="h-9 px-3 rounded-xl bg-surface-2 text-text/65 text-[13px] font-semibold hover:text-text"
+              >
+                {t('editor.field.daily_goal.clear')}
+              </button>
+            )}
+          </div>
+          <div className="text-[12px] text-text/55 mt-1.5 leading-snug">
+            {t('editor.field.daily_goal.hint')}
+          </div>
+        </Field>
+
+        <label className="flex items-start gap-3 cursor-pointer">
+          <input
+            type="checkbox"
+            checked={draft.adaptive ?? false}
+            onChange={(e) =>
+              setDraft({ ...draft, adaptive: e.target.checked })
+            }
+            className="mt-0.5 w-4 h-4 accent-accent"
+          />
+          <div>
+            <div className="text-[14px] font-semibold leading-tight">
+              {t('editor.field.adaptive.label')}
+            </div>
+            <div className="text-[12px] text-text/55 mt-1 leading-snug">
+              {t('editor.field.adaptive.hint')}
+            </div>
+          </div>
+        </label>
+
         <Field label={t('editor.field.icon')}>
           <div className="grid grid-cols-8 gap-2 max-h-44 overflow-y-auto p-2 rounded-2xl bg-surface-2">
             {ICON_CHOICES.map((name) => (

src/renderer/src/components/Titlebar.tsx

@@ -1,4 +1,5 @@
-import { Minus, X, Square, Menu } from 'lucide-react'
+import { Minus, X, Square, Copy, Menu } from 'lucide-react'
+import { useEffect, useState } from 'react'
 import { useT } from '../i18n'
 
 type Props = {
@@ -10,8 +11,29 @@ export function Titlebar({ title, onMenuClick }: Props): JSX.Element {
   const { t } = useT()
   const effectiveTitle = title ?? t('titlebar.app_title')
 
+  // Локально отслеживаем maximize-state, чтобы свапать иконку (квадрат ↔
+  // «двойной квадрат», как в нативной винде). Стартовое значение спрашиваем
+  // у main; дальше подписываемся на evtMaximizeChanged.
+  const [maximized, setMaximized] = useState(false)
+  useEffect(() => {
+    void window.api.isMaximizedMain().then(setMaximized)
+    const unsub = window.api.onMaximizeChanged((v) => setMaximized(v))
+    return unsub
+  }, [])
+
+  // Double-click по тайтлбару — стандартный Windows-жест для toggle maximize.
+  // Игнорируем клики по элементам с no-drag (кнопки/меню) — у них своя логика.
+  function onDoubleClick(e: React.MouseEvent<HTMLDivElement>): void {
+    const target = e.target as HTMLElement
+    if (target.closest('.titlebar-nodrag')) return
+    window.api.toggleMaximizeMain()
+  }
+
   return (
-    <div className="titlebar-drag relative h-10 px-2 sm:px-3 flex items-center justify-between vibrancy hairline-b">
+    <div
+      onDoubleClick={onDoubleClick}
+      className="titlebar-drag relative h-10 px-2 sm:px-3 flex items-center justify-between vibrancy hairline-b"
+    >
       <div className="flex items-center gap-1 min-w-0 flex-1 basis-0">
         {onMenuClick && (
           <button
@@ -28,7 +50,10 @@ export function Titlebar({ title, onMenuClick }: Props): JSX.Element {
         {effectiveTitle}
       </div>
 
-      <div className="titlebar-nodrag flex items-center justify-end gap-0.5 min-w-0 flex-1 basis-0">
+      {/* no-drag навешен на сами кнопки, не на обёртку: иначе из-за
+          flex-1 basis-0 весь кластер (включая пустое место слева от кнопок)
+          становится no-drag, и окно нельзя ухватить рядом с кнопками. */}
+      <div className="flex items-center justify-end gap-0.5 min-w-0 flex-1 basis-0">
         <WinBtn
           onClick={() => window.api.minimizeMain()}
           label={t('titlebar.minimize_aria')}
@@ -36,10 +61,18 @@ export function Titlebar({ title, onMenuClick }: Props): JSX.Element {
           <Minus size={13} strokeWidth={2} />
         </WinBtn>
         <WinBtn
-          onClick={() => window.api.hideMain()}
+          onClick={() => window.api.toggleMaximizeMain()}
-          label={t('titlebar.tray_aria')}
+          label={
+            maximized
+              ? t('titlebar.restore_aria')
+              : t('titlebar.maximize_aria')
+          }
         >
-          <Square size={11} strokeWidth={2} />
+          {maximized ? (
+            <Copy size={11} strokeWidth={2} />
+          ) : (
+            <Square size={11} strokeWidth={2} />
+          )}
         </WinBtn>
         <WinBtn
           onClick={() => window.api.closeMain()}
@@ -69,7 +102,7 @@ function WinBtn({
       onClick={onClick}
       aria-label={label}
       className={[
-        'w-9 h-7 grid place-items-center rounded-md transition-colors text-text/55',
+        'titlebar-nodrag w-9 h-7 grid place-items-center rounded-md transition-colors text-text/55',
         danger
           ? 'hover:bg-destructive hover:text-white'
           : 'hover:bg-text/[0.08] hover:text-text'

src/renderer/src/components/UpdaterCard.tsx

@@ -24,6 +24,9 @@ function formatChecked(ts: number, t: TFn): string {
 
 export function UpdaterCard(): JSX.Element {
   const [status, setStatus] = useState<UpdaterStatus>({ kind: 'idle' })
+  // busy используется только для синхронного `check()` — для асинхронного
+  // download/install статус сам переключится через события (downloading →
+  // downloaded), отдельный busy-флаг будет только дублировать визуально.
   const [busy, setBusy] = useState(false)
 
   useEffect(() => {
@@ -39,16 +42,15 @@ export function UpdaterCard(): JSX.Element {
       setBusy(false)
     }
   }
-  async function download(): Promise<void> {
+  function download(): void {
-    setBusy(true)
+    // Fire-and-forget — UI моментально перейдёт в kind:'downloading' через
-    try {
+    // первое же event'ное обновление статуса. Никакого `await` — пользователь
-      await window.api.updaterDownload()
+    // должен иметь возможность уйти на Dashboard, продолжать упражнения,
-    } finally {
+    // пока обновление качается в фоне.
-      setBusy(false)
+    window.api.updaterDownload()
-    }
   }
   function install(): void {
-    void window.api.updaterInstall()
+    window.api.updaterInstall()
   }
 
   return (
@@ -180,6 +182,10 @@ function Body({
             transition={{ duration: 0.3, ease: 'linear' }}
           />
         </div>
+        {/* Подсказка: download идёт в фоне, не нужно сидеть на этом экране. */}
+        <div className="text-[12px] text-text/55 mt-3 font-medium">
+          {t('updater.downloading.hint')}
+        </div>
       </div>
     )
   }

src/renderer/src/components/WhatsNewModal.tsx

@@ -0,0 +1,108 @@
+import { useMemo } from 'react'
+import { Sparkles, Wrench, Shield, Gauge } from 'lucide-react'
+import { Modal } from './ui/Modal'
+import { Button } from './ui/Button'
+import { useT } from '../i18n'
+import { RELEASE_NOTES } from '@shared/release-notes'
+import type { ReleaseNoteItem } from '@shared/release-notes'
+import type { Language } from '@shared/types'
+
+type Props = {
+  open: boolean
+  versions: string[]
+  onClose: () => void
+}
+
+const TAG_META = {
+  new: { icon: Sparkles, cls: 'bg-accent text-white' },
+  fix: { icon: Wrench, cls: 'bg-info text-white' },
+  security: { icon: Shield, cls: 'bg-warning text-white' },
+  perf: { icon: Gauge, cls: 'bg-success text-white' }
+} as const
+
+/**
+ * Показывает заметки релизов для одной или нескольких версий. Используется
+ * (a) автоматически после апдейта (когда `lastSeenVersion` != `currentVersion`)
+ * и (b) вручную из Settings.
+ */
+export function WhatsNewModal({
+  open,
+  versions,
+  onClose
+}: Props): JSX.Element {
+  const { t, lang } = useT()
+  return (
+    <Modal
+      open={open}
+      onClose={onClose}
+      title={t('whatsnew.title')}
+      size="md"
+      footer={<Button onClick={onClose}>{t('whatsnew.btn.close')}</Button>}
+    >
+      <div className="space-y-6">
+        {versions.length === 0 && (
+          <div className="text-[14px] text-text/65 font-medium py-2">
+            {t('whatsnew.empty')}
+          </div>
+        )}
+        {versions.map((v) => (
+          <VersionSection key={v} version={v} lang={lang} />
+        ))}
+      </div>
+    </Modal>
+  )
+}
+
+function VersionSection({
+  version,
+  lang
+}: {
+  version: string
+  lang: Language
+}): JSX.Element {
+  const items = useMemo<ReleaseNoteItem[]>(() => {
+    const notes = RELEASE_NOTES[version]
+    if (!notes) return []
+    return notes[lang] ?? notes.ru
+  }, [version, lang])
+
+  return (
+    <div>
+      <div className="text-[12px] uppercase tracking-wider text-text/55 font-bold mb-3 font-mono-num">
+        v{version}
+      </div>
+      <div className="space-y-2.5">
+        {items.map((it, i) => (
+          <NoteRow key={i} item={it} />
+        ))}
+      </div>
+    </div>
+  )
+}
+
+function NoteRow({ item }: { item: ReleaseNoteItem }): JSX.Element {
+  const meta = TAG_META[item.tag ?? 'new']
+  const IconCmp = meta.icon
+  return (
+    <div className="flex items-start gap-3">
+      <div
+        className={[
+          'w-8 h-8 rounded-lg grid place-items-center shrink-0 mt-0.5',
+          meta.cls
+        ].join(' ')}
+      >
+        <IconCmp size={15} strokeWidth={2.4} />
+      </div>
+      <div className="flex-1 min-w-0">
+        <div className="text-[14px] font-semibold leading-snug">
+          {item.title}
+        </div>
+        {item.detail && (
+          <div className="text-[13px] text-text/65 mt-1 leading-snug">
+            {item.detail}
+          </div>
+        )}
+      </div>
+    </div>
+  )
+}

src/renderer/src/components/ui/ConfirmModal.tsx

@@ -0,0 +1,62 @@
+import { Modal } from './Modal'
+import { Button } from './Button'
+import { useT } from '../../i18n'
+
+type Props = {
+  open: boolean
+  title: string
+  /** Текст вопроса (одно-два предложения). */
+  message: string
+  /** Текст кнопки подтверждения, default «OK». */
+  confirmLabel?: string
+  /** Текст кнопки отмены, default «Отмена». */
+  cancelLabel?: string
+  /** Подсветить confirm красным (delete-style). */
+  destructive?: boolean
+  onConfirm: () => void
+  onCancel: () => void
+}
+
+/**
+ * iOS-style confirm-диалог. Заменяет `window.confirm()` — нативный prompt
+ * выглядит инородно в дизайне приложения, без вибрации accent-цвета и без
+ * focus-trap'a. Использует наш Modal под капотом, поэтому получаем
+ * focus-trap и Esc-to-cancel бесплатно.
+ */
+export function ConfirmModal({
+  open,
+  title,
+  message,
+  confirmLabel,
+  cancelLabel,
+  destructive,
+  onConfirm,
+  onCancel
+}: Props): JSX.Element {
+  const { t } = useT()
+  return (
+    <Modal
+      open={open}
+      onClose={onCancel}
+      title={title}
+      size="sm"
+      footer={
+        <>
+          <Button variant="plain" onClick={onCancel}>
+            {cancelLabel ?? t('btn.cancel')}
+          </Button>
+          <Button
+            variant={destructive ? 'destructive' : 'filled'}
+            onClick={onConfirm}
+          >
+            {confirmLabel ?? t('btn.ok')}
+          </Button>
+        </>
+      }
+    >
+      <div className="text-[14px] text-text/85 leading-relaxed py-1">
+        {message}
+      </div>
+    </Modal>
+  )
+}

src/renderer/src/components/ui/Skeleton.tsx

@@ -0,0 +1,21 @@
+type Props = {
+  className?: string
+}
+
+/**
+ * Placeholder-блок на время загрузки данных. `aria-hidden` — это чисто
+ * визуальный шум, screen-reader'у он не нужен (рядом обычно есть role="status"
+ * или контент появится сам). Пульсация через Tailwind `animate-pulse`
+ * (гасится при prefers-reduced-motion — см. globals.css).
+ */
+export function Skeleton({ className = '' }: Props): JSX.Element {
+  return (
+    <div
+      aria-hidden="true"
+      className={[
+        'animate-pulse rounded-2xl bg-surface-2/70 dark:bg-surface-2',
+        className
+      ].join(' ')}
+    />
+  )
+}

src/renderer/src/components/ui/Spinner.tsx

@@ -0,0 +1,29 @@
+import { Loader2 } from 'lucide-react'
+
+type Props = {
+  size?: number
+  className?: string
+  /** Подпись для screen-reader'ов. По умолчанию нейтральное «Loading». */
+  label?: string
+}
+
+/**
+ * Индикатор асинхронной операции. `role="status"` + aria-label делают его
+ * слышимым для screen-reader'ов. Вращение через Tailwind `animate-spin`
+ * (замедляется, но не выключается при prefers-reduced-motion — см. globals.css).
+ */
+export function Spinner({
+  size = 16,
+  className = '',
+  label = 'Loading'
+}: Props): JSX.Element {
+  return (
+    <Loader2
+      size={size}
+      strokeWidth={2.4}
+      role="status"
+      aria-label={label}
+      className={['animate-spin', className].join(' ')}
+    />
+  )
+}

src/renderer/src/i18n/dict.ts

@@ -21,6 +21,8 @@ export const ru: Dict = {
   'sidebar.status_tracking': 'Активность отслеживается',
   'titlebar.menu_aria': 'Меню',
   'titlebar.minimize_aria': 'Свернуть',
+  'titlebar.maximize_aria': 'Развернуть',
+  'titlebar.restore_aria': 'Восстановить размер',
   'titlebar.tray_aria': 'В трей',
   'titlebar.close_aria': 'Закрыть',
   'titlebar.app_title': 'Exercise Reminder',
@@ -29,6 +31,15 @@ export const ru: Dict = {
   'btn.add': 'Добавить',
   'btn.new': 'Новый',
   'btn.cancel': 'Отмена',
+  'btn.ok': 'OK',
+  'btn.delete.confirm': 'Удалить',
+  'exercise.delete.title': 'Удалить упражнение?',
+  'exercise.delete.body':
+    'Упражнение «{name}» будет удалено. История останется, но в ней останется только название.',
+  'exercise.goal_reached.kicker': 'Цель закрыта',
+  'exercise.goal_reached.value': '{done}/{goal}',
+  'exercise.adaptive.badge': 'адаптивный режим',
+  'settings.data.import.modal.title': 'Восстановить из файла?',
   'btn.save': 'Сохранить',
   'btn.done': 'Готово',
   'btn.start': 'Старт',
@@ -63,10 +74,16 @@ export const ru: Dict = {
   'dashboard.stat.tracking': 'Трекинг матчей',
   'dashboard.stat.tracking.on': 'On',
   'dashboard.stat.tracking.off': 'Off',
+  'dashboard.stat.tracking.pending': 'Setup',
   'dashboard.stat.tracking.subtitle_on': 'в реальном времени',
   'dashboard.stat.tracking.subtitle_off': 'выключен',
+  'dashboard.stat.tracking.subtitle_pending':
+    'нужно закрыть Steam и снова открыть',
   'dashboard.paused.title': 'Напоминания на паузе',
   'dashboard.paused.hint': 'Возобнови, чтобы продолжить отсчёт',
+  'dashboard.meeting.title': 'Не дёргаем — ты на встрече',
+  'dashboard.meeting.hint':
+    'Запущен Zoom / Teams / Discord / Webex / Slack-huddle. Напоминания возобновятся когда закроешь.',
   'dashboard.empty.title': 'Программа пуста',
   'dashboard.empty.hint': 'Добавь первое упражнение, чтобы начать',
 
@@ -141,6 +158,30 @@ export const ru: Dict = {
   'settings.section.appearance': 'Внешний вид',
   'settings.section.language': 'Язык',
   'settings.section.updates': 'Обновления',
+  'settings.section.data': 'Данные',
+  'settings.data.export.label': 'Экспортировать всё',
+  'settings.data.export.hint':
+    'Сохрани резервную копию упражнений, истории, челленджей и настроек в JSON-файл.',
+  'settings.data.export.btn': 'Сохранить',
+  'settings.data.export.ok': 'Сохранено в {path}',
+  'settings.data.export.err': 'Не удалось сохранить',
+  'settings.data.import.label': 'Восстановить из файла',
+  'settings.data.import.hint':
+    'Загрузить ранее сохранённую копию. Текущие данные будут перезаписаны.',
+  'settings.data.import.btn': 'Восстановить',
+  'settings.data.import.confirm':
+    'Все текущие упражнения, история и настройки будут заменены содержимым файла. Продолжить?',
+  'settings.data.import.ok': 'Восстановлено',
+  'settings.data.import.err': 'Файл не подошёл — это не наша резервная копия?',
+  'settings.section.about': 'О приложении',
+  'settings.version.label': 'Версия',
+  'settings.version.hint': 'Текущая установленная версия приложения.',
+  'settings.whatsnew.label': 'Что нового',
+  'settings.whatsnew.hint': 'Посмотреть заметки последних релизов.',
+  'settings.whatsnew.btn': 'Открыть',
+  'whatsnew.title': 'Что нового',
+  'whatsnew.btn.close': 'Понятно',
+  'whatsnew.empty': 'Для этой версии заметок пока нет.',
   'settings.notification_mode.label': 'Режим уведомления',
   'settings.notification_mode.hint': 'Как должно выглядеть напоминание',
   'settings.notification_mode.modal': 'Окно поверх всех',
@@ -148,6 +189,12 @@ export const ru: Dict = {
   'settings.notification_mode.both': 'Окно и уведомление',
   'settings.sound.label': 'Звук уведомления',
   'settings.sound.hint': 'Короткий сигнал при срабатывании',
+  'settings.voice.label': 'Голосовая подсказка',
+  'settings.voice.hint':
+    'Диктор произносит название упражнения и количество — полезно когда фокус на коде.',
+  'settings.meeting_pause.label': 'Пауза на встречах',
+  'settings.meeting_pause.hint':
+    'Не дёргать, если запущен Zoom / Teams / Discord / Webex / Slack-huddle.',
   'settings.snooze.label': '«Отложить» на',
   'settings.snooze.hint': 'Сколько минут добавлять при отложении',
   'settings.snooze.1': '1 минута',
@@ -192,12 +239,54 @@ export const ru: Dict = {
   'updater.available.title': 'Доступна v{v}',
   'updater.downloading.title': 'Загружаем обновление',
   'updater.downloading.subtitle': '{got} / {total} МБ · {speed} МБ/с',
+  'updater.downloading.hint': 'Можно закрыть это окно — скачивание продолжится в фоне.',
   'updater.downloaded.title': 'Готово · v{v}',
-  'updater.downloaded.subtitle': 'Перезапусти для применения',
+  'updater.downloaded.subtitle': 'Нажми «Рестарт» — приложение моментально откроется в новой версии.',
   'updater.error.title': 'Ошибка проверки',
   'updater.idle.title': 'Проверить обновления',
   'updater.idle.subtitle': 'Авто-проверка раз в час',
 
+  // Achievements
+  'achievements.title': 'Достижения',
+  'achievements.unlocked_of': '{n} из {total}',
+  'achievements.progress': 'осталось {n}',
+  'achievements.announce': 'Достижение получено: {title}',
+  'achievement.reps.desc': 'Сделай {target} повторений всего',
+  'achievement.reps_100.title': 'Сотня',
+  'achievement.reps_500.title': 'Пятьсот',
+  'achievement.reps_1000.title': 'Тысяча',
+  'achievement.reps_5000.title': 'Пять тысяч',
+  'achievement.reps_10000.title': 'Десять тысяч',
+  'achievement.streak.desc': '{target} дней подряд',
+  'achievement.streak_3.title': 'Три дня',
+  'achievement.streak_7.title': 'Неделя',
+  'achievement.streak_14.title': 'Две недели',
+  'achievement.streak_30.title': 'Месяц',
+  'achievement.streak_100.title': 'Сто дней',
+  'achievement.first_day.title': 'Первый шаг',
+  'achievement.first_day.desc': 'Закрой первое напоминание',
+  'achievement.today_quad.title': 'Ударный день',
+  'achievement.today_quad.desc': '40+ повторений за день',
+
+  // Categories
+  'category.exercise': 'Упражнение',
+  'category.hydration': 'Гидратация',
+  'category.eyes': 'Отдых глазам',
+  'category.posture': 'Осанка',
+  'category.exercise.cta': 'Время тренировки',
+  'category.hydration.cta': 'Время попить',
+  'category.eyes.cta': 'Дай глазам отдохнуть',
+  'category.posture.cta': 'Проверь осанку',
+  'editor.field.category': 'Категория',
+  'editor.field.daily_goal': 'Дневная цель',
+  'editor.field.daily_goal.placeholder': 'без ограничения',
+  'editor.field.daily_goal.clear': 'Снять',
+  'editor.field.daily_goal.hint':
+    'Когда наберёшь столько повторений за день, напоминания этого упражнения умолкнут до завтра.',
+  'editor.field.adaptive.label': 'Адаптивное расписание',
+  'editor.field.adaptive.hint':
+    'Шедулер изучает, в какие часы ты чаще делаешь упражнение, и сдвигает напоминания на удобное тебе время. Заработает после 10 событий в истории.',
+
   // Reminder window
   'reminder.kicker': 'Время тренировки',
   'reminder.subkicker': 'Двигайся',
@@ -265,6 +354,8 @@ export const en: Dict = {
   'sidebar.status_tracking': 'Activity tracking is on',
   'titlebar.menu_aria': 'Menu',
   'titlebar.minimize_aria': 'Minimize',
+  'titlebar.maximize_aria': 'Maximize',
+  'titlebar.restore_aria': 'Restore size',
   'titlebar.tray_aria': 'To tray',
   'titlebar.close_aria': 'Close',
   'titlebar.app_title': 'Exercise Reminder',
@@ -273,6 +364,15 @@ export const en: Dict = {
   'btn.add': 'Add',
   'btn.new': 'New',
   'btn.cancel': 'Cancel',
+  'btn.ok': 'OK',
+  'btn.delete.confirm': 'Delete',
+  'exercise.delete.title': 'Delete exercise?',
+  'exercise.delete.body':
+    'Exercise "{name}" will be removed. History stays but will only show the name.',
+  'exercise.goal_reached.kicker': 'Goal hit',
+  'exercise.goal_reached.value': '{done}/{goal}',
+  'exercise.adaptive.badge': 'adaptive mode',
+  'settings.data.import.modal.title': 'Restore from file?',
   'btn.save': 'Save',
   'btn.done': 'Done',
   'btn.start': 'Start',
@@ -307,9 +407,14 @@ export const en: Dict = {
   'dashboard.stat.tracking': 'Match tracking',
   'dashboard.stat.tracking.on': 'On',
   'dashboard.stat.tracking.off': 'Off',
+  'dashboard.stat.tracking.pending': 'Setup',
   'dashboard.stat.tracking.subtitle_on': 'real-time',
   'dashboard.stat.tracking.subtitle_off': 'disabled',
+  'dashboard.stat.tracking.subtitle_pending': 'close & reopen Steam',
   'dashboard.paused.title': 'Reminders paused',
+  'dashboard.meeting.title': "You're in a meeting — won't interrupt",
+  'dashboard.meeting.hint':
+    'Zoom / Teams / Discord / Webex / Slack-huddle is running. Reminders resume when you close it.',
   'dashboard.paused.hint': 'Resume to continue countdown',
   'dashboard.empty.title': 'Program is empty',
   'dashboard.empty.hint': 'Add your first exercise to start',
@@ -385,6 +490,30 @@ export const en: Dict = {
   'settings.section.appearance': 'Appearance',
   'settings.section.language': 'Language',
   'settings.section.updates': 'Updates',
+  'settings.section.data': 'Data',
+  'settings.data.export.label': 'Export everything',
+  'settings.data.export.hint':
+    'Save a backup of exercises, history, challenges and settings to a JSON file.',
+  'settings.data.export.btn': 'Save',
+  'settings.data.export.ok': 'Saved to {path}',
+  'settings.data.export.err': 'Could not save',
+  'settings.data.import.label': 'Restore from file',
+  'settings.data.import.hint':
+    'Load a previously saved backup. Current data will be overwritten.',
+  'settings.data.import.btn': 'Restore',
+  'settings.data.import.confirm':
+    'All current exercises, history and settings will be replaced with the file contents. Continue?',
+  'settings.data.import.ok': 'Restored',
+  'settings.data.import.err': "Couldn't read the file — not our backup?",
+  'settings.section.about': 'About',
+  'settings.version.label': 'Version',
+  'settings.version.hint': 'Currently installed app version.',
+  'settings.whatsnew.label': "What's new",
+  'settings.whatsnew.hint': 'See the latest release notes.',
+  'settings.whatsnew.btn': 'Open',
+  'whatsnew.title': "What's new",
+  'whatsnew.btn.close': 'Got it',
+  'whatsnew.empty': 'No notes available for this version yet.',
   'settings.notification_mode.label': 'Notification mode',
   'settings.notification_mode.hint': 'How a reminder appears',
   'settings.notification_mode.modal': 'Window on top',
@@ -392,6 +521,12 @@ export const en: Dict = {
   'settings.notification_mode.both': 'Window and notification',
   'settings.sound.label': 'Notification sound',
   'settings.sound.hint': 'Short beep on trigger',
+  'settings.voice.label': 'Voice prompt',
+  'settings.voice.hint':
+    'Speaks the exercise name and count — useful when your eyes are on the code.',
+  'settings.meeting_pause.label': 'Pause during meetings',
+  'settings.meeting_pause.hint':
+    'Skip reminders when Zoom / Teams / Discord / Webex / Slack-huddle is running.',
   'settings.snooze.label': '“Snooze” for',
   'settings.snooze.hint': 'How many minutes to postpone',
   'settings.snooze.1': '1 minute',
@@ -436,12 +571,54 @@ export const en: Dict = {
   'updater.available.title': 'v{v} available',
   'updater.downloading.title': 'Downloading update',
   'updater.downloading.subtitle': '{got} / {total} MB · {speed} MB/s',
+  'updater.downloading.hint': 'You can close this window — download continues in the background.',
   'updater.downloaded.title': 'Ready · v{v}',
-  'updater.downloaded.subtitle': 'Restart to apply',
+  'updater.downloaded.subtitle': 'Click Restart — the app will reopen instantly in the new version.',
   'updater.error.title': 'Check failed',
   'updater.idle.title': 'Check for updates',
   'updater.idle.subtitle': 'Auto-check every hour',
 
+  // Achievements
+  'achievements.title': 'Achievements',
+  'achievements.unlocked_of': '{n} of {total}',
+  'achievements.progress': '{n} to go',
+  'achievements.announce': 'Achievement unlocked: {title}',
+  'achievement.reps.desc': '{target} reps total',
+  'achievement.reps_100.title': 'Century',
+  'achievement.reps_500.title': 'Five hundred',
+  'achievement.reps_1000.title': 'Thousand',
+  'achievement.reps_5000.title': 'Five thousand',
+  'achievement.reps_10000.title': 'Ten thousand',
+  'achievement.streak.desc': '{target} days in a row',
+  'achievement.streak_3.title': 'Three days',
+  'achievement.streak_7.title': 'Week',
+  'achievement.streak_14.title': 'Two weeks',
+  'achievement.streak_30.title': 'Month',
+  'achievement.streak_100.title': 'Hundred days',
+  'achievement.first_day.title': 'First step',
+  'achievement.first_day.desc': 'Close your first reminder',
+  'achievement.today_quad.title': 'Strong day',
+  'achievement.today_quad.desc': '40+ reps in one day',
+
+  // Categories
+  'category.exercise': 'Exercise',
+  'category.hydration': 'Hydration',
+  'category.eyes': 'Eye rest',
+  'category.posture': 'Posture',
+  'category.exercise.cta': 'Workout time',
+  'category.hydration.cta': 'Time to drink',
+  'category.eyes.cta': 'Rest your eyes',
+  'category.posture.cta': 'Check your posture',
+  'editor.field.category': 'Category',
+  'editor.field.daily_goal': 'Daily goal',
+  'editor.field.daily_goal.placeholder': 'no limit',
+  'editor.field.daily_goal.clear': 'Clear',
+  'editor.field.daily_goal.hint':
+    'Once you hit this many reps in a day, this reminder goes quiet until tomorrow.',
+  'editor.field.adaptive.label': 'Adaptive scheduling',
+  'editor.field.adaptive.hint':
+    'Scheduler learns which hours you reliably do this exercise and shifts reminders into your good windows. Kicks in after 10 history events.',
+
   // Reminder window
   'reminder.kicker': 'Workout time',
   'reminder.subkicker': 'Move',

src/renderer/src/i18n/i18n.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from 'vitest'
 import { translate, translateN } from './index'
+import { ru, en } from './dict'
 
 describe('translate', () => {
   it('returns the matching string by key', () => {
@@ -30,6 +31,50 @@ describe('translate', () => {
     // @ts-expect-error testing fallback
     expect(translate('fr', 'btn.save')).toBe('Сохранить')
   })
+
+  // Регрессия: до v0.5.2 интерполяция шла через regex, и если
+  // var-значение содержало regex-метасимволы ($1, .*, и т.д.), они
+  // интерпретировались как backreferences. Сейчас split/join.
+  it('substitutes regex metacharacters literally (no regex injection)', () => {
+    expect(
+      translate('ru', 'btn.snooze_min', { n: '$1.*' as unknown as number })
+    ).toBe('Отложить $1.* мин')
+    expect(
+      translate('en', 'btn.snooze_min', {
+        n: '$$$&\\1' as unknown as number
+      })
+    ).toBe('Snooze $$$&\\1m')
+  })
+
+  it('leaves unsubstituted placeholders intact', () => {
+    // {n} остаётся как есть, если var не передан — это сигнал «забыл vars».
+    expect(translate('ru', 'btn.snooze_min')).toContain('{n}')
+  })
+})
+
+describe('dictionary parity', () => {
+  // EN не имеет CLDR-категории `few` — только `one`/`many`. Поэтому RU-ключи
+  // вида `*_few` легитимно отсутствуют в EN, исключаем их из парити-чека.
+  const isRuFewOnly = (k: string): boolean => k.endsWith('_few')
+
+  it('every key in ru (except *_few) exists in en', () => {
+    const missing = Object.keys(ru).filter(
+      (k) => !isRuFewOnly(k) && !(k in en)
+    )
+    expect(missing, `missing in en: ${missing.join(', ')}`).toEqual([])
+  })
+
+  it('every key in en exists in ru', () => {
+    const missing = Object.keys(en).filter((k) => !(k in ru))
+    expect(missing, `missing in ru: ${missing.join(', ')}`).toEqual([])
+  })
+
+  it('weekday.short.0..6 exist in both languages', () => {
+    for (const i of [0, 1, 2, 3, 4, 5, 6]) {
+      expect(ru[`weekday.short.${i}`]).toBeTruthy()
+      expect(en[`weekday.short.${i}`]).toBeTruthy()
+    }
+  })
 })
 
 describe('translateN (plural)', () => {

src/renderer/src/lib/achievements.test.ts

@@ -0,0 +1,144 @@
+import { describe, expect, it } from 'vitest'
+import type { Exercise, HistoryEntry } from '@shared/types'
+import { computeAchievements } from './achievements'
+
+const MS_DAY = 24 * 60 * 60 * 1000
+
+function ex(id: string, reps: number): Exercise {
+  return {
+    id,
+    name: id,
+    reps,
+    icon: 'Activity',
+    intervalMinutes: 30,
+    enabled: true,
+    nextFireAt: 0
+  }
+}
+
+function done(exerciseId: string, ts: number, reps?: number): HistoryEntry {
+  const e: HistoryEntry = { exerciseId, ts, action: 'done' }
+  if (reps !== undefined) e.reps = reps
+  return e
+}
+
+describe('computeAchievements', () => {
+  it('first_day unlocks on first done', () => {
+    const exs = [ex('a', 10)]
+    const hist = [done('a', Date.now())]
+    const out = computeAchievements(hist, exs)
+    const first = out.find((a) => a.def.id === 'first_day')
+    expect(first?.unlocked).toBe(true)
+  })
+
+  it('first_day locked when no entries', () => {
+    const out = computeAchievements([], [])
+    const first = out.find((a) => a.def.id === 'first_day')
+    expect(first?.unlocked).toBe(false)
+  })
+
+  it('reps_100 unlocks at exactly 100 total reps', () => {
+    const exs = [ex('a', 10)]
+    // 10 done entries × 10 reps = 100
+    const hist = Array.from({ length: 10 }, (_, i) =>
+      done('a', Date.now() - i * 1000)
+    )
+    const out = computeAchievements(hist, exs)
+    const reps100 = out.find((a) => a.def.id === 'reps_100')
+    expect(reps100?.unlocked).toBe(true)
+    expect(reps100?.current).toBe(100)
+  })
+
+  it('reps_500 locked at 100 with progress', () => {
+    const exs = [ex('a', 10)]
+    const hist = Array.from({ length: 10 }, (_, i) =>
+      done('a', Date.now() - i * 1000)
+    )
+    const out = computeAchievements(hist, exs)
+    const reps500 = out.find((a) => a.def.id === 'reps_500')
+    expect(reps500?.unlocked).toBe(false)
+    expect(reps500?.current).toBe(100)
+    expect(reps500?.target).toBe(500)
+  })
+
+  it('streak_3 unlocks with 3 consecutive days ending today', () => {
+    const exs = [ex('a', 10)]
+    const today = new Date()
+    today.setHours(12, 0, 0, 0)
+    const hist = [
+      done('a', today.getTime()),
+      done('a', today.getTime() - MS_DAY),
+      done('a', today.getTime() - 2 * MS_DAY)
+    ]
+    const out = computeAchievements(hist, exs)
+    const s3 = out.find((a) => a.def.id === 'streak_3')
+    expect(s3?.unlocked).toBe(true)
+  })
+
+  it('streak_3 locked with gap in days', () => {
+    const exs = [ex('a', 10)]
+    const today = new Date()
+    today.setHours(12, 0, 0, 0)
+    const hist = [
+      done('a', today.getTime()),
+      done('a', today.getTime() - MS_DAY)
+      // отсутствует день -2 — стрик прерван
+    ]
+    const out = computeAchievements(hist, exs)
+    const s3 = out.find((a) => a.def.id === 'streak_3')
+    expect(s3?.unlocked).toBe(false)
+    expect(s3?.current).toBe(2)
+  })
+
+  it('today_quad unlocks at 40+ reps today', () => {
+    const exs = [ex('a', 50)]
+    const hist = [done('a', Date.now())]
+    const out = computeAchievements(hist, exs)
+    const q = out.find((a) => a.def.id === 'today_quad')
+    expect(q?.unlocked).toBe(true)
+    expect(q?.current).toBe(50)
+  })
+
+  it('today_quad locked at 30 reps', () => {
+    const exs = [ex('a', 30)]
+    const hist = [done('a', Date.now())]
+    const out = computeAchievements(hist, exs)
+    const q = out.find((a) => a.def.id === 'today_quad')
+    expect(q?.unlocked).toBe(false)
+    expect(q?.current).toBe(30)
+    expect(q?.target).toBe(40)
+  })
+
+  it('counts match-challenges via entry.reps snapshot', () => {
+    // Match challenge entries имеют exerciseId='challenge:<id>' и snapshot
+    // reps в поле reps. computeAchievements должен их учитывать.
+    const exs = [ex('a', 10)]
+    const today = Date.now()
+    const hist: HistoryEntry[] = [
+      // 100 reps от обычных
+      ...Array.from({ length: 10 }, (_, i) => done('a', today - i * 1000)),
+      // +50 от челленджа
+      {
+        exerciseId: 'challenge:abc',
+        ts: today,
+        action: 'done',
+        actualReps: 50,
+        reps: 50,
+        source: 'match'
+      }
+    ]
+    const out = computeAchievements(hist, exs)
+    const reps100 = out.find((a) => a.def.id === 'reps_100')
+    expect(reps100?.current).toBe(150) // 100 + 50
+  })
+
+  it('returns deterministic order matching DEFINITIONS', () => {
+    const out = computeAchievements([], [])
+    // Не пустой массив, есть все определённые достижения.
+    expect(out.length).toBeGreaterThan(5)
+    // reps_100 идёт раньше streak_3 (порядок DEFINITIONS).
+    const reps100Idx = out.findIndex((a) => a.def.id === 'reps_100')
+    const streak3Idx = out.findIndex((a) => a.def.id === 'streak_3')
+    expect(reps100Idx).toBeLessThan(streak3Idx)
+  })
+})

src/renderer/src/lib/achievements.ts

@@ -0,0 +1,155 @@
+/**
+ * Достижения = derived data из истории. Не persisting'ятся: при каждом
+ * прокладывании Dashboard'а пересчитываются из истории.
+ *
+ * Определение достижения: id, человеческий label/description, иконка
+ * (Lucide name), функция-проверка `progress(history, exercises) →
+ * { current, target }` где `current >= target` означает «получено».
+ *
+ * Этим UI получает не только список «полученных», но и прогресс по «почти-
+ * полученным», что важно мотивационно: «осталось 12 повторов до значка
+ * Сотня».
+ */
+import type { Exercise, HistoryEntry } from '@shared/types'
+import { currentStreak, dailyReps, dayKey } from './history'
+
+export type AchievementDef = {
+  id: string
+  /** Lucide icon name (whitelisted ICON_CHOICES не обязательно — иконки
+   * достижений отдельный набор). */
+  icon: string
+  tone: 'accent' | 'warning' | 'success' | 'info'
+  /** i18n-ключ для названия. */
+  titleKey: string
+  /** i18n-ключ описания. Принимает {target}. */
+  descKey: string
+}
+
+export type AchievementProgress = {
+  def: AchievementDef
+  current: number
+  target: number
+  /** Получено = current >= target. */
+  unlocked: boolean
+}
+
+/** Сумма всех done-повторений за всё время (учитывая actualReps). */
+function totalDoneReps(
+  history: HistoryEntry[],
+  exercises: Exercise[]
+): number {
+  const byId = new Map(exercises.map((e) => [e.id, e]))
+  let sum = 0
+  for (const e of history) {
+    if (e.action !== 'done') continue
+    sum += e.actualReps ?? e.reps ?? byId.get(e.exerciseId)?.reps ?? 0
+  }
+  return sum
+}
+
+/** Сколько уникальных done-дней за всё время. */
+function totalDoneDays(history: HistoryEntry[]): number {
+  const days = new Set<string>()
+  for (const e of history) {
+    if (e.action === 'done') days.add(dayKey(e.ts))
+  }
+  return days.size
+}
+
+/** Самый длинный завершённый streak (для historic-достижений). */
+function longestStreak(history: HistoryEntry[]): number {
+  const days = new Set<string>()
+  for (const e of history) {
+    if (e.action === 'done') days.add(dayKey(e.ts))
+  }
+  const sorted = Array.from(days).sort()
+  let max = 0
+  let cur = 0
+  let prev = ''
+  for (const d of sorted) {
+    if (prev) {
+      const prevDate = new Date(prev + 'T00:00:00')
+      const curDate = new Date(d + 'T00:00:00')
+      const diffDays = Math.round(
+        (curDate.getTime() - prevDate.getTime()) / (24 * 60 * 60 * 1000)
+      )
+      cur = diffDays === 1 ? cur + 1 : 1
+    } else {
+      cur = 1
+    }
+    if (cur > max) max = cur
+    prev = d
+  }
+  return max
+}
+
+const REPS_MILESTONES = [100, 500, 1000, 5000, 10000] as const
+const STREAK_MILESTONES = [3, 7, 14, 30, 100] as const
+
+const DEFINITIONS: AchievementDef[] = [
+  ...REPS_MILESTONES.map<AchievementDef>((n) => ({
+    id: `reps_${n}`,
+    icon: 'Activity',
+    tone: 'accent' as const,
+    titleKey: `achievement.reps_${n}.title`,
+    descKey: 'achievement.reps.desc'
+  })),
+  ...STREAK_MILESTONES.map<AchievementDef>((n) => ({
+    id: `streak_${n}`,
+    icon: 'Flame',
+    tone: 'warning' as const,
+    titleKey: `achievement.streak_${n}.title`,
+    descKey: 'achievement.streak.desc'
+  })),
+  {
+    id: 'first_day',
+    icon: 'Sparkles',
+    tone: 'success',
+    titleKey: 'achievement.first_day.title',
+    descKey: 'achievement.first_day.desc'
+  },
+  {
+    id: 'today_quad',
+    icon: 'TrendingUp',
+    tone: 'info',
+    titleKey: 'achievement.today_quad.title',
+    descKey: 'achievement.today_quad.desc'
+  }
+]
+
+export function computeAchievements(
+  history: HistoryEntry[],
+  exercises: Exercise[]
+): AchievementProgress[] {
+  const total = totalDoneReps(history, exercises)
+  const days = totalDoneDays(history)
+  const longest = longestStreak(history)
+  const currentStreakLen = currentStreak(history)
+  const today = dayKey(Date.now())
+  const todayCount = dailyReps(history, exercises, today)
+
+  return DEFINITIONS.map<AchievementProgress>((def) => {
+    if (def.id.startsWith('reps_')) {
+      const target = Number(def.id.split('_')[1])
+      return { def, current: total, target, unlocked: total >= target }
+    }
+    if (def.id.startsWith('streak_')) {
+      const target = Number(def.id.split('_')[1])
+      // Учитываем максимальный исторический и текущий — берём больший.
+      const cur = Math.max(longest, currentStreakLen)
+      return { def, current: cur, target, unlocked: cur >= target }
+    }
+    if (def.id === 'first_day') {
+      return { def, current: days >= 1 ? 1 : 0, target: 1, unlocked: days >= 1 }
+    }
+    if (def.id === 'today_quad') {
+      return {
+        def,
+        current: todayCount,
+        target: 40,
+        unlocked: todayCount >= 40
+      }
+    }
+    return { def, current: 0, target: 1, unlocked: false }
+  })
+}

src/renderer/src/lib/format.test.ts

@@ -33,6 +33,29 @@ describe('formatCountdown', () => {
     expect(formatCountdown(999)).toBe('0с')
     expect(formatCountdown(500)).toBe('0с')
   })
+
+  // Guard added in v0.5.2 — electron-updater и scheduler могут передать
+  // NaN/Infinity на ранних событиях. Должны вернуть «сейчас», не «NaNс».
+  it('returns "сейчас" for NaN and Infinity (defensive guard)', () => {
+    expect(formatCountdown(NaN)).toBe('сейчас')
+    expect(formatCountdown(Infinity)).toBe('сейчас')
+    expect(formatCountdown(-Infinity)).toBe('сейчас')
+  })
+
+  describe('english locale', () => {
+    it('renders sub-minute with "s"', () => {
+      expect(formatCountdown(45_000, 'en')).toBe('45s')
+    })
+    it('renders minutes+seconds with "m"/"s"', () => {
+      expect(formatCountdown(65_000, 'en')).toBe('1m 05s')
+    })
+    it('renders hours+minutes with "h"/"m"', () => {
+      expect(formatCountdown(3_660_000, 'en')).toBe('1h 01m')
+    })
+    it('returns "now" for zero', () => {
+      expect(formatCountdown(0, 'en')).toBe('now')
+    })
+  })
 })
 
 describe('formatInterval', () => {
@@ -53,4 +76,10 @@ describe('formatInterval', () => {
     expect(formatInterval(90)).toBe('1 ч 30 мин')
     expect(formatInterval(125)).toBe('2 ч 5 мин')
   })
+
+  it('english locale', () => {
+    expect(formatInterval(30, 'en')).toBe('30 min')
+    expect(formatInterval(60, 'en')).toBe('1 h')
+    expect(formatInterval(90, 'en')).toBe('1 h 30 min')
+  })
 })

src/renderer/src/lib/history.test.ts

@@ -1,6 +1,13 @@
 import { describe, expect, it } from 'vitest'
 import type { Exercise, HistoryEntry } from '@shared/types'
-import { currentStreak, dailyReps, dayKey, dailyRepsRange } from './history'
+import {
+  currentStreak,
+  dailyReps,
+  dayKey,
+  dailyRepsRange,
+  plannedRepsToday,
+  repsDoneTodayForExercise
+} from './history'
 
 const MS_DAY = 24 * 60 * 60 * 1000
 
@@ -117,4 +124,179 @@ describe('dailyRepsRange', () => {
     expect(range.at(-1)?.reps).toBe(10) // today
     expect(range.at(-2)?.reps).toBe(3) // yesterday, partial
   })
+
+  // DST regression: до v0.5.2 dailyRepsRange использовал `ts - i*MS_DAY`.
+  // На границе DST (например в EU last Sunday October — 25 час) арифметика
+  // ms-vs-календарь расходилась, и dayKey() выдавал дубликат/пропуск дня.
+  // Сейчас shiftDays() через setDate(). Простой инвариант: количество
+  // уникальных day-keys всегда == days, и все keys строго возрастают.
+  it('produces unique day keys without gaps (DST-safe)', () => {
+    const range = dailyRepsRange([], [], 90)
+    const keys = range.map((r) => r.key)
+    expect(new Set(keys).size).toBe(90)
+    for (let i = 1; i < keys.length; i++) {
+      expect(keys[i] > keys[i - 1]).toBe(true)
+    }
+  })
+
+  it('last entry is today', () => {
+    const range = dailyRepsRange([], [], 7)
+    expect(range.at(-1)?.key).toBe(dayKey(Date.now()))
+  })
+})
+
+describe('plannedRepsToday', () => {
+  it('returns 0 when no exercises enabled', () => {
+    const exs = [{ ...ex('a', 10), enabled: false }]
+    expect(plannedRepsToday(exs)).toBe(0)
+  })
+
+  it('returns 0 for empty list', () => {
+    expect(plannedRepsToday([])).toBe(0)
+  })
+
+  it('multiplies reps by approximate fires per day', () => {
+    // 60-min interval × 24 = 24 fires/day × 10 reps = 240
+    const exs = [{ ...ex('a', 10), intervalMinutes: 60 }]
+    expect(plannedRepsToday(exs)).toBe(240)
+  })
+
+  it('sums across multiple enabled exercises', () => {
+    const exs = [
+      { ...ex('a', 10), intervalMinutes: 60 }, // 24 × 10 = 240
+      { ...ex('b', 5), intervalMinutes: 30 } // 48 × 5 = 240
+    ]
+    expect(plannedRepsToday(exs)).toBe(480)
+  })
+
+  it('floor of (1440/interval), minimum 1 fire/day for huge intervals', () => {
+    // 1440-min interval = 1 fire/day; 2000-min interval should still be ≥ 1.
+    const exs = [{ ...ex('a', 7), intervalMinutes: 2000 }]
+    expect(plannedRepsToday(exs)).toBe(7)
+  })
+})
+
+describe('currentStreak edge cases', () => {
+  const today = Date.now()
+
+  it('ignores future-dated entries (clock skew, partial restore)', () => {
+    const tomorrow = today + 24 * 60 * 60 * 1000
+    // future entry shouldn't anchor the streak.
+    expect(currentStreak([entry('a', tomorrow)])).toBe(0)
+  })
+
+  it('handles entries spread across the same day with mixed actions', () => {
+    const e = (
+      action: 'done' | 'skip' | 'snooze',
+      ts: number
+    ): HistoryEntry => entry('a', ts, action)
+    const hist = [
+      e('skip', today),
+      e('done', today), // done is enough — streak counts the day
+      e('snooze', today)
+    ]
+    expect(currentStreak(hist)).toBe(1)
+  })
+})
+
+describe('repsDoneTodayForExercise', () => {
+  const today = Date.now()
+  const exercise = ex('a', 10)
+  const other = ex('b', 5)
+
+  it('returns 0 if no entries', () => {
+    expect(repsDoneTodayForExercise([], exercise)).toBe(0)
+  })
+
+  it('counts only entries for this exercise today', () => {
+    const hist = [
+      entry('a', today),
+      entry('a', today),
+      entry('b', today), // other exercise — игнорируем
+      entry('a', today - 2 * 24 * 60 * 60 * 1000) // позавчера — игнорируем
+    ]
+    expect(repsDoneTodayForExercise(hist, exercise)).toBe(20)
+    expect(repsDoneTodayForExercise(hist, other)).toBe(5)
+  })
+
+  it('uses actualReps when set', () => {
+    const hist = [entry('a', today, 'done', 7), entry('a', today)]
+    expect(repsDoneTodayForExercise(hist, exercise)).toBe(7 + 10)
+  })
+
+  it('ignores skip / snooze entries', () => {
+    const hist = [
+      entry('a', today, 'skip'),
+      entry('a', today, 'snooze'),
+      entry('a', today)
+    ]
+    expect(repsDoneTodayForExercise(hist, exercise)).toBe(10)
+  })
+
+  it('prefers entry.reps snapshot over exercise.reps (historical accuracy)', () => {
+    // Контракт: entry.reps это «сколько было запланировано на момент
+    // записи». Если пользователь раньше делал 15 раз приседаний, потом
+    // изменил планку на 10 — history должна показывать 15 для старых
+    // entries, не 10. Это правильнее для аналитики «что я тогда делал».
+    const histWithSnapshot: HistoryEntry[] = [
+      { exerciseId: 'a', ts: today, action: 'done', reps: 15 }
+    ]
+    expect(repsDoneTodayForExercise(histWithSnapshot, exercise)).toBe(15)
+  })
+
+  it('falls back to exercise.reps when entry has no snapshot', () => {
+    // Старые entries (до Sprint #1 / v0.5.7) не имеют entry.reps.
+    // Должны fall'back'нуться на текущий exercise.reps.
+    const histOldEntry: HistoryEntry[] = [
+      { exerciseId: 'a', ts: today, action: 'done' }
+    ]
+    expect(repsDoneTodayForExercise(histOldEntry, exercise)).toBe(10)
+  })
+
+  it('survives match challenges (exerciseId=challenge:<id>)', () => {
+    // Match-челлендж не привязан к exercise — repsDoneTodayForExercise
+    // его игнорирует (это не reps для этого упражнения).
+    const hist: HistoryEntry[] = [
+      {
+        exerciseId: 'challenge:abc',
+        ts: today,
+        action: 'done',
+        actualReps: 30,
+        reps: 30,
+        source: 'match'
+      }
+    ]
+    expect(repsDoneTodayForExercise(hist, exercise)).toBe(0)
+  })
+})
+
+describe('dailyReps with new entry.reps snapshot', () => {
+  const today = Date.now()
+  const exs = [ex('a', 10)]
+
+  it('counts match-challenge entries via entry.reps snapshot', () => {
+    // У match-челленджа exerciseId='challenge:<id>', byId.get вернёт
+    // undefined. entry.reps snapshot — единственный источник.
+    const hist: HistoryEntry[] = [
+      {
+        exerciseId: 'challenge:abc',
+        ts: today,
+        action: 'done',
+        actualReps: 30,
+        reps: 30,
+        source: 'match'
+      },
+      entry('a', today) // обычная entry — 10 reps через byId
+    ]
+    expect(dailyReps(hist, exs, dayKey(today))).toBe(40)
+  })
+
+  it('survives deleted exercise via entry.reps snapshot', () => {
+    // Упражнение 'gone' удалено, но entry.reps=8 был записан до удаления.
+    const hist: HistoryEntry[] = [
+      { exerciseId: 'gone', ts: today, action: 'done', reps: 8 }
+    ]
+    // byId.get('gone') = undefined → fallback на entry.reps=8.
+    expect(dailyReps(hist, exs, dayKey(today))).toBe(8)
+  })
 })

src/renderer/src/lib/history.ts

@@ -30,6 +30,35 @@ function shiftDays(base: Date, dayDelta: number): Date {
  * Reps logged on a given local day. Uses `actualReps` if present, otherwise
  * looks up exercise's planned `reps`.
  */
+/**
+ * Сколько reps пользователь сделал в заданный day-key. Источники в порядке
+ * приоритета:
+ *   1. entry.actualReps — что фактически сделал (stepper в reminder'е)
+ *   2. entry.reps — snapshot planned-reps на момент записи (выживает после
+ *      удаления упражнения и работает для match-челленджей у которых нет
+ *      связанного Exercise)
+ *   3. byId.get(exerciseId).reps — fallback для старых entries без snapshot'а
+ */
+/**
+ * Сколько reps конкретное упражнение принесло за сегодня. Учитываем как
+ * обычные «по таймеру», так и match-челленджи (если их exerciseId совпадает,
+ * чего обычно нет; но fallback не помешает).
+ */
+export function repsDoneTodayForExercise(
+  entries: HistoryEntry[],
+  exercise: Exercise
+): number {
+  const today = todayKey()
+  let sum = 0
+  for (const e of entries) {
+    if (e.action !== 'done') continue
+    if (e.exerciseId !== exercise.id) continue
+    if (dayKey(e.ts) !== today) continue
+    sum += e.actualReps ?? e.reps ?? exercise.reps
+  }
+  return sum
+}
+
 export function dailyReps(
   entries: HistoryEntry[],
   exercises: Exercise[],
@@ -40,7 +69,7 @@ export function dailyReps(
   for (const e of entries) {
     if (e.action !== 'done') continue
     if (dayKey(e.ts) !== dayKeyStr) continue
-    sum += e.actualReps ?? byId.get(e.exerciseId)?.reps ?? 0
+    sum += e.actualReps ?? e.reps ?? byId.get(e.exerciseId)?.reps ?? 0
   }
   return sum
 }
@@ -72,7 +101,7 @@ export function dailyRepsRange(
     const k = dayKey(e.ts)
     const bucket = buckets.get(k)
     if (!bucket) continue
-    const reps = e.actualReps ?? byId.get(e.exerciseId)?.reps ?? 0
+    const reps = e.actualReps ?? e.reps ?? byId.get(e.exerciseId)?.reps ?? 0
     bucket.reps += reps
   }
 

src/renderer/src/lib/icon-choices.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from 'vitest'
+import { ICON_CHOICES } from './icon-choices'
+import { SAMPLE_EXERCISES } from '@shared/types'
+
+describe('ICON_CHOICES', () => {
+  // Если иконка SAMPLE_EXERCISES не входит в whitelist, при первом запуске
+  // приложения иконка молча заменится на fallback-Activity. Лучше ловить
+  // расхождение в CI.
+  it('contains every icon used by SAMPLE_EXERCISES', () => {
+    const allowed = new Set<string>(ICON_CHOICES)
+    for (const ex of SAMPLE_EXERCISES) {
+      expect(
+        allowed.has(ex.icon),
+        `icon "${ex.icon}" for sample "${ex.name}" is not in ICON_CHOICES`
+      ).toBe(true)
+    }
+  })
+
+  it('has no duplicates', () => {
+    expect(new Set(ICON_CHOICES).size).toBe(ICON_CHOICES.length)
+  })
+
+  it('is non-empty', () => {
+    expect(ICON_CHOICES.length).toBeGreaterThan(0)
+  })
+})

src/renderer/src/lib/icon-choices.ts

@@ -0,0 +1,27 @@
+/**
+ * Whitelist of allowed Lucide-icon names. Wrapped in a separate .ts file
+ * (без JSX), чтобы его можно было импортировать из node-tests и из shared/
+ * без подтягивания JSX-зависимости icon.tsx.
+ */
+export const ICON_CHOICES = [
+  'Activity',
+  'Dumbbell',
+  'StretchHorizontal',
+  'PersonStanding',
+  'Heart',
+  'Footprints',
+  'Hand',
+  'Eye',
+  'Brain',
+  'Bike',
+  'Waves',
+  'Wind',
+  'Sun',
+  'Coffee',
+  'Apple',
+  'GlassWater',
+  'BookOpen',
+  'Sparkles'
+] as const
+
+export type IconName = (typeof ICON_CHOICES)[number]

src/renderer/src/lib/icon.tsx

@@ -1,30 +1,51 @@
-import * as Lucide from 'lucide-react'
+// Explicit-named imports — НЕ wildcard. Wildcard `* as Lucide` ломает
+// tree-shaking: в bundle попадает вся библиотека (~500KB minified, 1500+
+// иконок). Сейчас в bundle только 18 ICON_CHOICES.
+import {
+  Activity,
+  Dumbbell,
+  StretchHorizontal,
+  PersonStanding,
+  Heart,
+  Footprints,
+  Hand,
+  Eye,
+  Brain,
+  Bike,
+  Waves,
+  Wind,
+  Sun,
+  Coffee,
+  Apple,
+  GlassWater,
+  BookOpen,
+  Sparkles
+} from 'lucide-react'
 import type { LucideProps } from 'lucide-react'
+import { ICON_CHOICES, type IconName } from './icon-choices'
 
-export const ICON_CHOICES = [
+export { ICON_CHOICES, type IconName }
-  'Activity',
-  'Dumbbell',
-  'StretchHorizontal',
-  'PersonStanding',
-  'Heart',
-  'Footprints',
-  'Hand',
-  'Eye',
-  'Brain',
-  'Bike',
-  'Waves',
-  'Wind',
-  'Sun',
-  'Coffee',
-  'Apple',
-  'GlassWater',
-  'BookOpen',
-  'Sparkles'
-] as const
 
-export type IconName = (typeof ICON_CHOICES)[number]
+const ICON_MAP: Record<IconName, React.ComponentType<LucideProps>> = {
-
+  Activity,
-const ICON_SET = new Set<string>(ICON_CHOICES)
+  Dumbbell,
+  StretchHorizontal,
+  PersonStanding,
+  Heart,
+  Footprints,
+  Hand,
+  Eye,
+  Brain,
+  Bike,
+  Waves,
+  Wind,
+  Sun,
+  Coffee,
+  Apple,
+  GlassWater,
+  BookOpen,
+  Sparkles
+}
 
 /**
  * Render a Lucide icon by name. Restricted to the curated ICON_CHOICES set —
@@ -36,15 +57,12 @@ export function Icon({
   name,
   ...props
 }: { name: string } & LucideProps): JSX.Element {
-  if (!ICON_SET.has(name)) {
+  const Cmp = ICON_MAP[name as IconName]
+  if (!Cmp) {
     if (import.meta.env.DEV) {
       console.warn(`[Icon] unknown icon name "${name}" — falling back`)
     }
-    return <Lucide.Activity {...props} />
+    return <Activity {...props} />
   }
-  const Cmp = (
-    Lucide as unknown as Record<string, React.ComponentType<LucideProps>>
-  )[name]
-  if (!Cmp) return <Lucide.Activity {...props} />
   return <Cmp {...props} />
 }

src/renderer/src/lib/tts.ts

@@ -0,0 +1,67 @@
+/**
+ * Тонкая обёртка над Web Speech API для голосовых подсказок упражнений.
+ *
+ * Используется в ReminderApp при `settings.voicePromptsEnabled`. Голос
+ * подбирается под `settings.language`: ищем первый локальный голос
+ * с правильным `lang` префиксом (ru-RU / en-US), fallback на default.
+ *
+ * Тихий fail: если браузер/Electron не поддерживает Speech Synthesis
+ * (мало вероятно в Chromium) — просто ничего не делаем, не падаем.
+ */
+import type { Language } from '@shared/types'
+
+const LANG_BCP47: Record<Language, string> = {
+  ru: 'ru-RU',
+  en: 'en-US'
+}
+
+let voicesLoaded = false
+let cachedVoices: SpeechSynthesisVoice[] = []
+
+function ensureVoices(): SpeechSynthesisVoice[] {
+  if (typeof window === 'undefined' || !('speechSynthesis' in window)) return []
+  if (voicesLoaded && cachedVoices.length) return cachedVoices
+  cachedVoices = window.speechSynthesis.getVoices()
+  // Chromium часто отдаёт пустой массив до voiceschanged-event'а — подпишемся
+  // один раз, чтобы при следующем speak() voices уже были.
+  if (cachedVoices.length === 0) {
+    window.speechSynthesis.onvoiceschanged = () => {
+      cachedVoices = window.speechSynthesis.getVoices()
+      voicesLoaded = true
+    }
+  } else {
+    voicesLoaded = true
+  }
+  return cachedVoices
+}
+
+function pickVoice(lang: Language): SpeechSynthesisVoice | undefined {
+  const target = LANG_BCP47[lang]
+  const voices = ensureVoices()
+  // 1. Точное совпадение `ru-RU` / `en-US`.
+  const exact = voices.find((v) => v.lang === target)
+  if (exact) return exact
+  // 2. Любой голос с правильным language-кодом (`ru`, `en`).
+  const partial = voices.find((v) => v.lang.startsWith(lang))
+  if (partial) return partial
+  // 3. Default — fallback на default-голос системы.
+  return voices.find((v) => v.default)
+}
+
+export function speak(text: string, lang: Language): void {
+  if (typeof window === 'undefined' || !('speechSynthesis' in window)) return
+  try {
+    // Прервать предыдущее озвучивание (если игрок быстро жмёт reminder'ы).
+    window.speechSynthesis.cancel()
+    const utter = new SpeechSynthesisUtterance(text)
+    const voice = pickVoice(lang)
+    if (voice) utter.voice = voice
+    utter.lang = LANG_BCP47[lang]
+    utter.rate = 1.0
+    utter.pitch = 1.0
+    utter.volume = 0.85
+    window.speechSynthesis.speak(utter)
+  } catch {
+    // Не критично — TTS опционален.
+  }
+}

src/renderer/src/lib/useAnnounce.ts

@@ -0,0 +1,49 @@
+import { useCallback } from 'react'
+
+/**
+ * Озвучивание событий для screen-reader'ов через единый скрытый
+ * aria-live регион. Анимации/тосты видят зрячие; незрячим нужно явное
+ * сообщение — иначе «достижение разблокировано» или «упражнение засчитано»
+ * проходят молча.
+ *
+ * Регион — module-level singleton (один на окно), создаётся лениво и живёт
+ * до закрытия окна. Так не нужен провайдер в дереве компонентов.
+ */
+let region: HTMLElement | null = null
+
+function ensureRegion(): HTMLElement {
+  if (region && document.body.contains(region)) return region
+  const el = document.createElement('div')
+  el.setAttribute('aria-live', 'polite')
+  el.setAttribute('aria-atomic', 'true')
+  el.setAttribute('role', 'status')
+  // Визуально скрыто, но доступно для screen-reader'ов (sr-only pattern).
+  Object.assign(el.style, {
+    position: 'absolute',
+    width: '1px',
+    height: '1px',
+    margin: '-1px',
+    padding: '0',
+    overflow: 'hidden',
+    clip: 'rect(0 0 0 0)',
+    whiteSpace: 'nowrap',
+    border: '0'
+  })
+  document.body.appendChild(el)
+  region = el
+  return el
+}
+
+export function useAnnounce(): (message: string) => void {
+  return useCallback((message: string) => {
+    if (!message) return
+    const el = ensureRegion()
+    // Сброс перед записью: screen-reader игнорирует повторную установку
+    // идентичного текста. Разносим очистку и значение по разным кадрам,
+    // чтобы изменение точно зарегистрировалось.
+    el.textContent = ''
+    requestAnimationFrame(() => {
+      el.textContent = message
+    })
+  }, [])
+}

src/renderer/src/main.tsx

@@ -1,5 +1,6 @@
 import React from 'react'
 import ReactDOM from 'react-dom/client'
+import { MotionConfig } from 'framer-motion'
 import './styles/globals.css'
 import App from './App'
 import ReminderApp from './ReminderApp'
@@ -8,10 +9,15 @@ import { ThemeProvider } from './providers/ThemeProvider'
 const params = new URLSearchParams(window.location.search)
 const which = params.get('window') ?? 'main'
 
+// reducedMotion="user" — framer-motion сам читает системную настройку
+// «уменьшить движение» и глушит transform/layout-анимации (оставляя opacity).
+// Один источник истины для обоих окон и всех motion-компонентов.
 ReactDOM.createRoot(document.getElementById('root')!).render(
   <React.StrictMode>
-    <ThemeProvider>
+    <MotionConfig reducedMotion="user">
-      {which === 'reminder' ? <ReminderApp /> : <App />}
+      <ThemeProvider>
-    </ThemeProvider>
+        {which === 'reminder' ? <ReminderApp /> : <App />}
+      </ThemeProvider>
+    </MotionConfig>
   </React.StrictMode>
 )

src/renderer/src/pages/Challenges.tsx

@@ -22,12 +22,16 @@ const GAME_NAMES: Record<GameId, string> = {
 
 type Draft = Omit<Challenge, 'id'>
 
+// exerciseName умышленно пустой — пусть пользователь сам выберет что
+// делать. Раньше дефолт был «Приседания» — в EN-локали это выглядело как
+// баг (русский текст в английском UI). Required-валидация всё равно
+// требует непустого значения перед save.
 const EMPTY_DRAFT: Draft = {
   name: '',
   gameId: 'dota2',
   stat: 'deaths',
   multiplier: 3,
-  exerciseName: 'Приседания',
+  exerciseName: '',
   icon: 'Activity',
   enabled: true
 }
@@ -135,8 +139,13 @@ export default function ChallengesPage(): JSX.Element {
           </>
         ) : (
           <Card>
-            <div className="px-5 py-12 text-center text-text/65 text-[15px] font-medium">
+            <div className="px-5 py-12 flex flex-col items-center text-center">
-              {t('challenges.empty')}
+              <div className="inline-flex w-14 h-14 rounded-2xl bg-accent text-white items-center justify-center mb-4">
+                <Gamepad2 size={24} strokeWidth={2.4} />
+              </div>
+              <div className="text-text/65 text-[15px] font-medium max-w-xs leading-snug">
+                {t('challenges.empty')}
+              </div>
             </div>
           </Card>
         )}
@@ -264,11 +273,18 @@ function ChallengeEditor({
               type="number"
               step="0.5"
               min="0.5"
+              max="1000"
               value={draft.multiplier}
               onChange={(e) =>
                 setDraft({
                   ...draft,
-                  multiplier: Math.max(0.5, Number(e.target.value) || 1)
+                  // Клампим к диапазону [0.5, 1000] — совпадает с validate.ts
+                  // (multiplier ∈ [0, 1000]). Без max=1000 пользователь мог
+                  // ввести 9999 и save молча отклонялся IPC-валидатором.
+                  multiplier: Math.max(
+                    0.5,
+                    Math.min(1000, Number(e.target.value) || 1)
+                  )
                 })
               }
               className="ios-input font-mono-num"

src/renderer/src/pages/Dashboard.tsx

@@ -1,21 +1,37 @@
 import { useEffect, useMemo, useState } from 'react'
 import { AnimatePresence, motion } from 'framer-motion'
-import { Plus, Pause, Play, Flame, Activity, TrendingUp } from 'lucide-react'
+import {
+  Plus,
+  Pause,
+  Play,
+  Flame,
+  Activity,
+  TrendingUp,
+  Video
+} from 'lucide-react'
 import { useAppStore } from '../store/appStore'
 import { ExerciseCard } from '../components/ExerciseCard'
 import { ExerciseEditor } from '../components/ExerciseEditor'
 import { HistoryHeatmap } from '../components/HistoryHeatmap'
+import { AchievementsCard } from '../components/AchievementsCard'
 import { Button } from '../components/ui/Button'
-import type { Exercise, HistoryEntry } from '@shared/types'
+import { ConfirmModal } from '../components/ui/ConfirmModal'
+import type { Exercise, GameStatus, HistoryEntry } from '@shared/types'
 import { formatCountdown } from '../lib/format'
 import { useT } from '../i18n'
-import { currentStreak, dailyReps, todayKey } from '../lib/history'
+import {
+  currentStreak,
+  dailyReps,
+  repsDoneTodayForExercise,
+  todayKey
+} from '../lib/history'
 
 export default function Dashboard(): JSX.Element {
   const state = useAppStore((s) => s.state)
   const ticks = useAppStore((s) => s.ticks)
   const [editorOpen, setEditorOpen] = useState(false)
   const [editing, setEditing] = useState<Exercise | null>(null)
+  const [deleting, setDeleting] = useState<Exercise | null>(null)
   const { t, lang } = useT()
 
   // Memoise the exercises array reference so downstream useMemos don't fire
@@ -23,16 +39,53 @@ export default function Dashboard(): JSX.Element {
   // the parent re-renders even when nothing changed.
   const exercises = useMemo(() => state?.exercises ?? [], [state?.exercises])
   const settings = state?.settings
-  const gamesEnabled = Object.values(state?.gamesEnabled ?? {}).some(Boolean)
 
-  // Local history mirror; reloaded only when exercises change (not on every
+  // Игры: запрашиваем реальный статус (integrationActive + launchOption
-  // tick or settings tweak — those don't affect history). When ticks/settings
+  // applied), а не просто `state.gamesEnabled`. Без этого badge показывал
-  // change we don't re-fetch.
+  // success-зелёный даже когда launch option ещё «queued» (Steam перезапи-
+  // сывает) — пользователь думал что GSI работает, а fires не приходили.
+  const [games, setGames] = useState<GameStatus[]>([])
+  useEffect(() => {
+    void window.api.listGames().then(setGames)
+    return window.api.onGamesChanged(setGames)
+  }, [])
+  const gamesLive = games.some(
+    (g) =>
+      g.enabled &&
+      g.integrationActive &&
+      g.launchOptionStatus === 'applied'
+  )
+  // «Включена, но не готова» — отдельное состояние, в badge другой tone.
+  const gamesEnabledButNotLive = games.some(
+    (g) => g.enabled && (!g.integrationActive || g.launchOptionStatus !== 'applied')
+  )
+
+  // Local history mirror. Перетягиваем (а) на mount, (б) при изменении
+  // exercises (add/delete/edit — могут поменять name/icon в snapshot'ах
+  // для будущих entries), (в) при evtHistoryChanged — это event который
+  // main отправляет ПОСЛЕ любого markDone/markChallengeDone/clearHistory/
+  // import. Без (в) heatmap и стрик стояли на месте после markDone —
+  // store мутирует exercise in place, ref не меняется, useEffect не
+  // fire'ил.
   const [history, setHistory] = useState<HistoryEntry[]>([])
   useEffect(() => {
-    void window.api.getHistory().then(setHistory)
+    const refetch = (): void => {
+      void window.api.getHistory().then(setHistory)
+    }
+    refetch()
+    return window.api.onHistoryChanged(refetch)
   }, [exercises])
 
+  // Meeting auto-pause indicator: подписываемся на evtMeetingChanged +
+  // запрашиваем актуальное значение при mount. Показываем баннер только
+  // если фича включена в settings.
+  const [meetingActive, setMeetingActive] = useState(false)
+  useEffect(() => {
+    void window.api.getMeetingActive().then(setMeetingActive)
+    return window.api.onMeetingChanged(setMeetingActive)
+  }, [])
+  const meetingPaused = meetingActive && settings?.meetingAutoPause === true
+
   const todayDone = useMemo(
     () => dailyReps(history, exercises, todayKey()),
     [history, exercises]
@@ -72,6 +125,9 @@ export default function Dashboard(): JSX.Element {
     icon: string
     intervalMinutes: number
     enabled: boolean
+    category: import('@shared/types').ReminderCategory
+    dailyGoal?: number
+    adaptive?: boolean
   }): Promise<void> {
     if (editing) await window.api.updateExercise(editing.id, draft)
     else await window.api.addExercise(draft)
@@ -154,23 +210,29 @@ export default function Dashboard(): JSX.Element {
             icon={<Activity size={14} strokeWidth={2.6} />}
           />
           <HeroStat
-            tone={gamesEnabled ? 'success' : 'muted'}
+            tone={
+              gamesLive ? 'success' : gamesEnabledButNotLive ? 'warning' : 'muted'
+            }
             label={t('dashboard.stat.tracking')}
             value={
-              gamesEnabled
+              gamesLive
                 ? t('dashboard.stat.tracking.on')
-                : t('dashboard.stat.tracking.off')
+                : gamesEnabledButNotLive
+                  ? t('dashboard.stat.tracking.pending')
+                  : t('dashboard.stat.tracking.off')
             }
             subvalue={
-              gamesEnabled
+              gamesLive
                 ? t('dashboard.stat.tracking.subtitle_on')
-                : t('dashboard.stat.tracking.subtitle_off')
+                : gamesEnabledButNotLive
+                  ? t('dashboard.stat.tracking.subtitle_pending')
+                  : t('dashboard.stat.tracking.subtitle_off')
             }
             icon={
               <span
                 className={[
                   'w-1.5 h-1.5 rounded-full',
-                  gamesEnabled ? 'bg-white' : 'bg-text/30'
+                  gamesLive ? 'bg-white' : 'bg-text/30'
                 ].join(' ')}
               />
             }
@@ -178,8 +240,9 @@ export default function Dashboard(): JSX.Element {
         </div>
 
         {history.length > 0 && (
-          <div className="mb-8">
+          <div className="mb-8 space-y-3">
             <HistoryHeatmap history={history} exercises={exercises} />
+            <AchievementsCard history={history} exercises={exercises} />
           </div>
         )}
 
@@ -206,6 +269,26 @@ export default function Dashboard(): JSX.Element {
           </motion.div>
         )}
 
+        {!paused && meetingPaused && (
+          <motion.div
+            initial={{ opacity: 0, y: -4 }}
+            animate={{ opacity: 1, y: 0 }}
+            className="mb-6 rounded-2xl bg-info/12 p-4 flex items-center gap-3"
+          >
+            <div className="w-10 h-10 rounded-xl bg-info/18 text-info grid place-items-center shrink-0">
+              <Video size={18} strokeWidth={2.5} />
+            </div>
+            <div className="flex-1 min-w-0">
+              <div className="text-[16px] font-semibold leading-tight">
+                {t('dashboard.meeting.title')}
+              </div>
+              <div className="text-[14px] text-text/70 mt-1">
+                {t('dashboard.meeting.hint')}
+              </div>
+            </div>
+          </motion.div>
+        )}
+
         <div className="grid grid-cols-1 md:grid-cols-2 xl:grid-cols-2 gap-4">
           <AnimatePresence>
             {exercises.map((ex) => (
@@ -213,8 +296,13 @@ export default function Dashboard(): JSX.Element {
                 key={ex.id}
                 exercise={ex}
                 tick={ticks[ex.id]}
+                doneToday={
+                  ex.dailyGoal !== undefined
+                    ? repsDoneTodayForExercise(history, ex)
+                    : undefined
+                }
                 onEdit={() => openEdit(ex)}
-                onDelete={() => window.api.deleteExercise(ex.id)}
+                onDelete={() => setDeleting(ex)}
                 onToggle={(v) => window.api.toggleExercise(ex.id, v)}
                 onMarkDone={() => window.api.markDone(ex.id)}
               />
@@ -242,6 +330,19 @@ export default function Dashboard(): JSX.Element {
           onClose={() => setEditorOpen(false)}
           onSave={handleSave}
         />
+
+        <ConfirmModal
+          open={deleting !== null}
+          title={t('exercise.delete.title')}
+          message={t('exercise.delete.body', { name: deleting?.name ?? '' })}
+          confirmLabel={t('btn.delete.confirm')}
+          destructive
+          onConfirm={() => {
+            if (deleting) void window.api.deleteExercise(deleting.id)
+            setDeleting(null)
+          }}
+          onCancel={() => setDeleting(null)}
+        />
       </div>
     </div>
   )

src/renderer/src/pages/Exercises.tsx

@@ -93,8 +93,13 @@ export default function Exercises(): JSX.Element {
 
         {exercises.length === 0 && (
           <Card>
-            <div className="px-5 py-12 text-center text-text/65 text-[15px] font-medium">
+            <div className="px-5 py-12 flex flex-col items-center text-center">
-              {t('exercises.empty')}
+              <div className="inline-flex w-14 h-14 rounded-2xl bg-accent text-white items-center justify-center mb-4">
+                <Plus size={24} strokeWidth={2.5} />
+              </div>
+              <div className="text-text/65 text-[15px] font-medium max-w-xs leading-snug">
+                {t('exercises.empty')}
+              </div>
             </div>
           </Card>
         )}

src/renderer/src/pages/Games.tsx

@@ -11,6 +11,7 @@ import {
 import { motion } from 'framer-motion'
 import { Button } from '../components/ui/Button'
 import { Switch } from '../components/ui/Switch'
+import { Spinner } from '../components/ui/Spinner'
 import { Card, SectionHeader } from '../components/ui/Card'
 import type { GameId, GameStatus } from '@shared/types'
 import { useT } from '../i18n'
@@ -104,7 +105,11 @@ export default function GamesPage(): JSX.Element {
           ))}
           {games.length === 0 && (
             <Card>
-              <div className="px-5 py-12 text-center text-text/55 text-[14px]">
+              <div
+                className="px-5 py-12 flex flex-col items-center gap-3 text-center text-text/55 text-[14px]"
+                role="status"
+              >
+                <Spinner size={22} className="text-accent" label={t('games.scanning')} />
                 {t('games.scanning')}
               </div>
             </Card>
@@ -201,7 +206,12 @@ function GameCard({
       <div className="flex items-center flex-wrap gap-2 mt-4">
         {game.installed && !game.integrationActive && (
           <Button onClick={onInstall} disabled={busy} size="sm">
-            <Download size={14} strokeWidth={2.5} /> {t('btn.connect')}
+            {busy ? (
+              <Spinner size={14} />
+            ) : (
+              <Download size={14} strokeWidth={2.5} />
+            )}{' '}
+            {t('btn.connect')}
           </Button>
         )}
         {game.integrationActive && (
@@ -211,7 +221,8 @@ function GameCard({
             disabled={busy}
             size="sm"
           >
-            <Trash2 size={14} strokeWidth={2.5} /> {t('btn.disconnect')}
+            {busy ? <Spinner size={14} /> : <Trash2 size={14} strokeWidth={2.5} />}{' '}
+            {t('btn.disconnect')}
           </Button>
         )}
         {!game.installed && (

src/renderer/src/pages/Settings.tsx

@@ -3,6 +3,11 @@ import { useAppStore } from '../store/appStore'
 import { Switch } from '../components/ui/Switch'
 import { Card, Row, SectionHeader } from '../components/ui/Card'
 import { UpdaterCard } from '../components/UpdaterCard'
+import { WhatsNewModal } from '../components/WhatsNewModal'
+import { ConfirmModal } from '../components/ui/ConfirmModal'
+import { Skeleton } from '../components/ui/Skeleton'
+import { Spinner } from '../components/ui/Spinner'
+import { RELEASE_NOTES } from '@shared/release-notes'
 import { useT } from '../i18n'
 import type {
   Language,
@@ -16,7 +21,18 @@ export default function SettingsPage(): JSX.Element {
   const settings = useAppStore((s) => s.state?.settings)
   const { t } = useT()
   if (!settings)
-    return <div className="p-8 text-text/45">{t('settings.loading')}</div>
+    return (
+      <div
+        className="max-w-2xl mx-auto px-4 sm:px-6 lg:px-10 pt-8 pb-12 space-y-5"
+        role="status"
+        aria-label={t('settings.loading')}
+      >
+        <Skeleton className="h-10 w-56" />
+        <Skeleton className="h-32" />
+        <Skeleton className="h-32" />
+        <Skeleton className="h-24" />
+      </div>
+    )
 
   const patch = (p: Partial<SettingsType>): void => {
     window.api.updateSettings(p)
@@ -77,6 +93,18 @@ export default function SettingsPage(): JSX.Element {
             checked={settings.soundEnabled}
             onChange={(v) => patch({ soundEnabled: v })}
           />
+          <ToggleRow
+            label={t('settings.voice.label')}
+            hint={t('settings.voice.hint')}
+            checked={settings.voicePromptsEnabled}
+            onChange={(v) => patch({ voicePromptsEnabled: v })}
+          />
+          <ToggleRow
+            label={t('settings.meeting_pause.label')}
+            hint={t('settings.meeting_pause.hint')}
+            checked={settings.meetingAutoPause}
+            onChange={(v) => patch({ meetingAutoPause: v })}
+          />
           <SelectRow
             label={t('settings.snooze.label')}
             hint={t('settings.snooze.hint')}
@@ -158,11 +186,176 @@ export default function SettingsPage(): JSX.Element {
 
         <SectionHeader title={t('settings.section.updates')} />
         <UpdaterCard />
+
+        <div className="mt-6">
+          <SectionHeader title={t('settings.section.data')} />
+          <DataCard />
+        </div>
+
+        <div className="mt-6">
+          <SectionHeader title={t('settings.section.about')} />
+          <AboutCard />
+        </div>
       </div>
     </div>
   )
 }
 
+function AboutCard(): JSX.Element {
+  const { t } = useT()
+  const [open, setOpen] = useState(false)
+  const [version, setVersion] = useState<string>('')
+  useEffect(() => {
+    void window.api.getAppVersion().then(setVersion)
+  }, [])
+  // Все версии для которых у нас есть заметки, отсортированы desc.
+  const allVersions = Object.keys(RELEASE_NOTES).sort((a, b) => {
+    const pa = a.split('.').map(Number)
+    const pb = b.split('.').map(Number)
+    for (let i = 0; i < 3; i++) if (pa[i] !== pb[i]) return pb[i] - pa[i]
+    return 0
+  })
+  return (
+    <Card>
+      <Row>
+        <div className="flex-1 min-w-0">
+          <div className="text-[15px] font-semibold leading-tight">
+            {t('settings.version.label')}
+          </div>
+          <div className="text-[13px] text-text/65 mt-1 leading-snug">
+            {t('settings.version.hint')}
+          </div>
+        </div>
+        <div className="text-[14px] font-mono-num font-semibold text-text/70">
+          {version ? `v${version}` : '—'}
+        </div>
+      </Row>
+      <Row last>
+        <div className="flex-1 min-w-0">
+          <div className="text-[15px] font-semibold leading-tight">
+            {t('settings.whatsnew.label')}
+          </div>
+          <div className="text-[13px] text-text/65 mt-1 leading-snug">
+            {t('settings.whatsnew.hint')}
+          </div>
+        </div>
+        <button
+          onClick={() => setOpen(true)}
+          className="h-9 px-4 rounded-xl bg-surface-2 hover:bg-hairline/25 text-[14px] font-semibold transition-colors"
+        >
+          {t('settings.whatsnew.btn')}
+        </button>
+      </Row>
+      <WhatsNewModal
+        open={open}
+        versions={allVersions}
+        onClose={() => setOpen(false)}
+      />
+    </Card>
+  )
+}
+
+function DataCard(): JSX.Element {
+  const { t } = useT()
+  // Какая операция сейчас идёт — чтобы крутить спиннер на нужной кнопке,
+  // а не на обеих сразу.
+  const [busy, setBusy] = useState<'export' | 'import' | null>(null)
+  const [toast, setToast] = useState<string | null>(null)
+  const [confirmOpen, setConfirmOpen] = useState(false)
+
+  // Простое toast'-сообщение в карточке; через 4 сек чистится.
+  useEffect(() => {
+    if (!toast) return
+    const id = setTimeout(() => setToast(null), 4000)
+    return () => clearTimeout(id)
+  }, [toast])
+
+  async function onExport(): Promise<void> {
+    setBusy('export')
+    try {
+      const r = await window.api.exportState()
+      if (r.ok && r.path) {
+        setToast(t('settings.data.export.ok', { path: r.path }))
+      } else if (!r.ok && !r.canceled) {
+        // canceled — пользователь сам передумал, тост не нужен.
+        setToast(t('settings.data.export.err'))
+      }
+    } finally {
+      setBusy(null)
+    }
+  }
+
+  async function performImport(): Promise<void> {
+    setConfirmOpen(false)
+    setBusy('import')
+    try {
+      const r = await window.api.importState()
+      if (r.ok) setToast(t('settings.data.import.ok'))
+      else if (!r.canceled) {
+        // canceled — пользователь не выбрал файл, не показываем error.
+        setToast(t('settings.data.import.err'))
+      }
+    } finally {
+      setBusy(null)
+    }
+  }
+
+  return (
+    <Card>
+      <Row>
+        <div className="flex-1 min-w-0">
+          <div className="text-[15px] font-semibold leading-tight">
+            {t('settings.data.export.label')}
+          </div>
+          <div className="text-[13px] text-text/65 mt-1 leading-snug">
+            {t('settings.data.export.hint')}
+          </div>
+        </div>
+        <button
+          onClick={onExport}
+          disabled={busy !== null}
+          className="inline-flex items-center gap-2 h-9 px-4 rounded-xl bg-surface-2 hover:bg-hairline/25 text-[14px] font-semibold transition-colors disabled:opacity-50"
+        >
+          {busy === 'export' && <Spinner size={14} />}
+          {t('settings.data.export.btn')}
+        </button>
+      </Row>
+      <Row last>
+        <div className="flex-1 min-w-0">
+          <div className="text-[15px] font-semibold leading-tight">
+            {t('settings.data.import.label')}
+          </div>
+          <div className="text-[13px] text-text/65 mt-1 leading-snug">
+            {t('settings.data.import.hint')}
+          </div>
+        </div>
+        <button
+          onClick={() => setConfirmOpen(true)}
+          disabled={busy !== null}
+          className="inline-flex items-center gap-2 h-9 px-4 rounded-xl bg-surface-2 hover:bg-hairline/25 text-[14px] font-semibold transition-colors disabled:opacity-50"
+        >
+          {busy === 'import' && <Spinner size={14} />}
+          {t('settings.data.import.btn')}
+        </button>
+      </Row>
+      {toast && (
+        <div className="px-4 py-2.5 text-[13px] text-text/75 bg-accent/8 truncate font-medium">
+          {toast}
+        </div>
+      )}
+      <ConfirmModal
+        open={confirmOpen}
+        title={t('settings.data.import.modal.title')}
+        message={t('settings.data.import.confirm')}
+        confirmLabel={t('settings.data.import.btn')}
+        destructive
+        onConfirm={performImport}
+        onCancel={() => setConfirmOpen(false)}
+      />
+    </Card>
+  )
+}
+
 function ToggleRow({
   label,
   hint,

src/renderer/src/providers/ThemeProvider.tsx

@@ -25,5 +25,15 @@ export function ThemeProvider({
     else document.documentElement.classList.remove('dark')
   }, [settings?.theme, osTheme])
 
+  // Синхронизируем <html lang> с языком приложения. Без этого screen-readers
+  // продолжают читать английский текст как кириллицу (или ломаются) при
+  // переключении на EN, и наоборот — это a11y-баг.
+  useEffect(() => {
+    const lang = settings?.language ?? 'ru'
+    if (document.documentElement.lang !== lang) {
+      document.documentElement.lang = lang
+    }
+  }, [settings?.language])
+
   return <>{children}</>
 }

src/renderer/src/styles/globals.css

@@ -1,3 +1,21 @@
+/* Self-hosted шрифты — раньше тянулись с fonts.googleapis.com через <link>
+   в index.html. Минусы: внешняя зависимость (без интернета шрифты не
+   загружаются), CSP вынужден разрешать style-src https://fonts.googleapis.com
+   и font-src https://fonts.gstatic.com. Сейчас локальные .woff2 в bundle. */
+@import '@fontsource/plus-jakarta-sans/400.css';
+@import '@fontsource/plus-jakarta-sans/500.css';
+@import '@fontsource/plus-jakarta-sans/600.css';
+@import '@fontsource/plus-jakarta-sans/700.css';
+@import '@fontsource/plus-jakarta-sans/800.css';
+@import '@fontsource/bricolage-grotesque/500.css';
+@import '@fontsource/bricolage-grotesque/600.css';
+@import '@fontsource/bricolage-grotesque/700.css';
+@import '@fontsource/bricolage-grotesque/800.css';
+@import '@fontsource/jetbrains-mono/400.css';
+@import '@fontsource/jetbrains-mono/500.css';
+@import '@fontsource/jetbrains-mono/600.css';
+@import '@fontsource/jetbrains-mono/700.css';
+
 @tailwind base;
 @tailwind components;
 @tailwind utilities;
@@ -212,3 +230,25 @@ body {
 .dark .text-tertiary {
   color: rgb(var(--text-tertiary) / 0.3);
 }
+
+/* ===== Reduced motion =====
+   framer-motion закрывает свои анимации через MotionConfig reducedMotion="user"
+   (см. main.tsx). Этот блок гасит CSS-анимации/переходы, которые framer не
+   контролирует (Tailwind animate-spin/-pulse, нативные transition). Спиннеры
+   намеренно НЕ обнуляем полностью — индикатор загрузки должен крутиться, иначе
+   пропадает смысл; но замедляем, чтобы не мелькал. */
+@media (prefers-reduced-motion: reduce) {
+  *,
+  *::before,
+  *::after {
+    animation-duration: 0.001ms !important;
+    animation-iteration-count: 1 !important;
+    transition-duration: 0.001ms !important;
+    scroll-behavior: auto !important;
+  }
+  /* Спиннеры — единственное исключение: оставляем вращение, но медленнее. */
+  .animate-spin {
+    animation-duration: 1.2s !important;
+    animation-iteration-count: infinite !important;
+  }
+}

src/shared/ipc.ts

@@ -11,11 +11,14 @@ export const IPC = {
   updateSettings: 'settings:update',
   getAccentColor: 'system:accentColor',
   getOsTheme: 'system:osTheme',
+  getAppVersion: 'system:appVersion',
 
   pauseAll: 'app:pauseAll',
   resumeAll: 'app:resumeAll',
   quit: 'app:quit',
   minimizeMain: 'window:minimize',
+  toggleMaximizeMain: 'window:toggleMaximize',
+  isMaximizedMain: 'window:isMaximized',
   closeMain: 'window:close',
   hideMain: 'window:hide',
 
@@ -36,6 +39,10 @@ export const IPC = {
   markChallengeDone: 'challenge:markDone',
   closeMatchSummary: 'matchSummary:close',
 
+  // Dev-only IPC (handler ungated в prod, см. ipc.ts). Держим в enum чтобы
+  // main/preload/renderer не разошлись в hardcoded-строках.
+  devSimulateMatchEnd: 'dev:simulateMatchEnd',
+
   // Auto-updater
   updaterStatus: 'updater:status',
   updaterCheck: 'updater:check',
@@ -46,6 +53,10 @@ export const IPC = {
   getHistory: 'history:get',
   clearHistory: 'history:clear',
 
+  // Export / Import
+  exportState: 'state:export',
+  importState: 'state:import',
+
   // events from main → renderer
   evtTick: 'evt:tick',
   evtFire: 'evt:fire',
@@ -54,5 +65,18 @@ export const IPC = {
   evtThemeChanged: 'evt:themeChanged',
   evtAccentChanged: 'evt:accentChanged',
   evtGamesChanged: 'evt:gamesChanged',
-  evtUpdaterStatus: 'evt:updaterStatus'
+  evtUpdaterStatus: 'evt:updaterStatus',
+  evtMaximizeChanged: 'evt:maximizeChanged',
+  evtMeetingChanged: 'evt:meetingChanged',
+  /**
+   * Шлётся когда история мутирует (markDone / snooze / skip /
+   * markChallengeDone / clearHistory / import). Renderer'у достаточно
+   * перезапросить getHistory. Раньше Dashboard переключал history по
+   * `exercises` ref'у — но markDone мутирует Exercise in place, ref не
+   * меняется, и heatmap стояла. Этот event — единый сигнал что надо
+   * перетянуть.
+   */
+  evtHistoryChanged: 'evt:historyChanged',
+
+  getMeetingActive: 'system:meetingActive'
 } as const

src/shared/release-notes.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, it } from 'vitest'
+import { unseenVersions, RELEASE_NOTES } from './release-notes'
+
+describe('unseenVersions', () => {
+  // Завязываемся на реальный RELEASE_NOTES — это OK, тест защищает контракт.
+  // Если из RELEASE_NOTES удалят ключ, упадёт expect.
+
+  it('returns only current version when lastSeen is undefined (new user proxy)', () => {
+    // Логика: при отсутствии lastSeen возвращаем только current — мы НЕ
+    // знаем, новичок это или нет; UI решает (через exercises.lastDoneAt).
+    // Эта функция только показывает «что было бы показано».
+    const result = unseenVersions('0.5.6', undefined)
+    expect(result).toEqual(['0.5.6'])
+  })
+
+  it('returns nothing when lastSeen equals current', () => {
+    expect(unseenVersions('0.5.6', '0.5.6')).toEqual([])
+  })
+
+  it('returns versions strictly between lastSeen and current (desc)', () => {
+    // Юзер видел 0.5.4, обновился на 0.5.7 → видит 0.5.5, 0.5.6, 0.5.7.
+    const result = unseenVersions('0.5.7', '0.5.4')
+    // Порядок desc (новейшее сверху).
+    expect(result[0]).toBe('0.5.7')
+    expect(result).toContain('0.5.5')
+    expect(result).toContain('0.5.6')
+    expect(result).not.toContain('0.5.4')
+    expect(result).not.toContain('0.5.3')
+  })
+
+  it('skips versions beyond current (no notes for not-yet-installed releases)', () => {
+    // Юзер видел 0.5.4, current=0.5.5 → видит только 0.5.5, не 0.5.6+.
+    const result = unseenVersions('0.5.5', '0.5.4')
+    expect(result).toEqual(['0.5.5'])
+  })
+
+  it('handles versions with patch increments correctly', () => {
+    const result = unseenVersions('0.5.7', '0.5.6')
+    expect(result).toEqual(['0.5.7'])
+  })
+
+  it('lastSeen ahead of current returns empty (downgrade case)', () => {
+    const result = unseenVersions('0.5.3', '0.5.5')
+    expect(result).toEqual([])
+  })
+})
+
+describe('RELEASE_NOTES contract', () => {
+  it('has both ru and en for every version', () => {
+    for (const [v, notes] of Object.entries(RELEASE_NOTES)) {
+      expect(notes.ru, `v${v} missing ru notes`).toBeTruthy()
+      expect(notes.en, `v${v} missing en notes`).toBeTruthy()
+      expect(notes.ru.length, `v${v} empty ru`).toBeGreaterThan(0)
+      expect(notes.en.length, `v${v} empty en`).toBeGreaterThan(0)
+    }
+  })
+
+  it('all version keys match semver-light /^\\d+\\.\\d+\\.\\d+$/', () => {
+    for (const v of Object.keys(RELEASE_NOTES)) {
+      expect(v).toMatch(/^\d+\.\d+\.\d+$/)
+    }
+  })
+
+  it('every note item has title; tag is in allowed set if present', () => {
+    const allowedTags = new Set(['new', 'fix', 'security', 'perf'])
+    for (const notes of Object.values(RELEASE_NOTES)) {
+      for (const lang of ['ru', 'en'] as const) {
+        for (const it of notes[lang]) {
+          expect(it.title.length).toBeGreaterThan(0)
+          if (it.tag) expect(allowedTags.has(it.tag)).toBe(true)
+        }
+      }
+    }
+  })
+})

src/shared/release-notes.ts

@@ -0,0 +1,373 @@
+/**
+ * Заметки релизов для UI «Что нового». Хардкодные — синхронизируются
+ * с CHANGELOG.md руками при релизе. Не парсим .md в runtime: лишняя
+ * сложность, плюс отделение «коротких заметок для пользователя» от
+ * «развёрнутого технического CHANGELOG'а».
+ *
+ * Формат: версия → язык → массив пунктов (короткий заголовок + опц. деталь).
+ * Не более 5-7 пунктов на версию, иначе пользователь скроллит.
+ */
+import type { Language } from './types'
+
+export type ReleaseNoteItem = {
+  /** Лаконичная строка-заголовок (≤ 60 символов). */
+  title: string
+  /** Опциональная одна строка-деталь (≤ 140 символов). */
+  detail?: string
+  /** Категория для tint'а иконки. */
+  tag?: 'new' | 'fix' | 'security' | 'perf'
+}
+
+export type ReleaseNotes = Record<Language, ReleaseNoteItem[]>
+
+export const RELEASE_NOTES: Record<string, ReleaseNotes> = {
+  '0.5.8': {
+    ru: [
+      {
+        title: 'Heatmap и стрик обновляются сразу после нажатия «Готово»',
+        detail:
+          'Был регресс — статистика не обновлялась пока не изменишь упражнение. Починено через новое событие evtHistoryChanged.',
+        tag: 'fix'
+      },
+      {
+        title: 'Двойной клик на ✓ больше не пишет 2 раза',
+        detail:
+          'Rapid double-click на ✓ в Match Summary и «Готово» давал лишние повторы в стрик. Добавлен ref-based дедуп.',
+        tag: 'fix'
+      },
+      {
+        title: 'Native save/open dialogs локализованы',
+        tag: 'fix'
+      },
+      {
+        title: '+18 тестов на новые модули',
+        detail:
+          'achievements, match-challenge edge cases, deleted exercise survival.',
+        tag: 'new'
+      }
+    ],
+    en: [
+      {
+        title: 'Heatmap and streak update immediately after pressing "Done"',
+        detail:
+          'There was a regression — stats did not update until you edited an exercise. Fixed via new evtHistoryChanged event.',
+        tag: 'fix'
+      },
+      {
+        title: 'Double-click on ✓ no longer writes twice',
+        detail:
+          'Rapid double-click on ✓ in Match Summary and "Done" added extra reps to streak. ref-based dedup.',
+        tag: 'fix'
+      },
+      {
+        title: 'Native save/open dialogs localised',
+        tag: 'fix'
+      },
+      {
+        title: '+18 tests for new modules',
+        detail:
+          'achievements, match-challenge edge cases, deleted exercise survival.',
+        tag: 'new'
+      }
+    ]
+  },
+  '0.5.7': {
+    ru: [
+      {
+        title: 'Челленджи из матчей идут в историю',
+        detail:
+          'Раньше ✓ в Match Summary не считался — стрик и достижения игнорировали игровые тренировки. Исправлено.',
+        tag: 'fix'
+      },
+      {
+        title: 'Пауза из трея и из Dashboard теперь синхронизированы',
+        detail: 'Раньше Dashboard показывал «running» когда tray был на паузе.',
+        tag: 'fix'
+      },
+      {
+        title: 'Удаление упражнения спрашивает подтверждение',
+        tag: 'fix'
+      },
+      {
+        title: 'Daily goal: «Цель закрыта · 100/100»',
+        detail:
+          'Когда дневная цель достигнута — больше не показываем обратный отсчёт «25ч 13м».',
+        tag: 'fix'
+      },
+      {
+        title: 'Видно когда мы молчим из-за ВКС',
+        detail:
+          'Запущен Zoom/Teams — на Dashboard баннер «Не дёргаем — ты на встрече».',
+        tag: 'new'
+      },
+      {
+        title: 'Celebration анимация на новых достижениях',
+        tag: 'new'
+      },
+      {
+        title: 'Tracking-badge точнее',
+        detail:
+          'Live / Setup (закрой Steam) / Off — раньше зелёный показывался даже когда launch option не применён.',
+        tag: 'fix'
+      }
+    ],
+    en: [
+      {
+        title: 'Match challenges now write to history',
+        detail:
+          'Previously ✓ in Match Summary did not count — streak and achievements ignored game training. Fixed.',
+        tag: 'fix'
+      },
+      {
+        title: 'Tray pause and Dashboard pause are now synced',
+        detail: "Previously Dashboard showed 'running' while tray was paused.",
+        tag: 'fix'
+      },
+      {
+        title: 'Exercise deletion asks for confirmation',
+        tag: 'fix'
+      },
+      {
+        title: 'Daily goal: "Goal hit · 100/100"',
+        detail:
+          'When the daily goal is met — no more confusing 25h countdown to tomorrow.',
+        tag: 'fix'
+      },
+      {
+        title: "Visible when we're quiet because of a meeting",
+        detail:
+          "Zoom/Teams running — Dashboard shows a banner: 'You're in a meeting'.",
+        tag: 'new'
+      },
+      {
+        title: 'Celebration animation on newly unlocked achievements',
+        tag: 'new'
+      },
+      {
+        title: 'Tracking badge more accurate',
+        detail:
+          'Live / Setup (close Steam) / Off — previously green even when launch option was not applied.',
+        tag: 'fix'
+      }
+    ]
+  },
+  '0.5.6': {
+    ru: [
+      {
+        title: 'Категории напоминаний',
+        detail:
+          'Помимо упражнений — гидратация, отдых глазам (20-20-20), осанка.',
+        tag: 'new'
+      },
+      {
+        title: 'Голосовые подсказки',
+        detail:
+          'Диктор произносит название упражнения и количество. Включается в настройках.',
+        tag: 'new'
+      },
+      {
+        title: 'Достижения',
+        detail:
+          'Milestones по количеству повторений и серий — с прогресс-баром до ближайшей цели.',
+        tag: 'new'
+      },
+      {
+        title: 'Дневная цель',
+        detail:
+          'Soft-cap на упражнение: набрал N повторов — реминдер умолкает до завтра.',
+        tag: 'new'
+      },
+      {
+        title: 'Авто-пауза на ВКС',
+        detail:
+          'Не дёргает напоминаниями, если запущен Zoom/Teams/Discord/Webex/Slack-huddle.',
+        tag: 'new'
+      },
+      {
+        title: 'Адаптивный шедулер',
+        detail:
+          'Учит часы, в которые ты честно делаешь упражнение, и сдвигает fire-ы туда.',
+        tag: 'new'
+      },
+      {
+        title: 'Экспорт и импорт',
+        detail:
+          'Резервная копия упражнений, истории и настроек в JSON — для переноса на другую машину.',
+        tag: 'new'
+      },
+      {
+        title: 'Кнопка «Что нового»',
+        detail: 'Это окно. Открывается автоматически после обновления.',
+        tag: 'new'
+      }
+    ],
+    en: [
+      {
+        title: 'Reminder categories',
+        detail:
+          'Beyond exercises — hydration, eye rest (20-20-20), posture.',
+        tag: 'new'
+      },
+      {
+        title: 'Voice prompts',
+        detail:
+          'Speaks the exercise name and count. Toggle in Settings.',
+        tag: 'new'
+      },
+      {
+        title: 'Achievements',
+        detail:
+          'Milestones by total reps and streaks, with a progress bar to the next one.',
+        tag: 'new'
+      },
+      {
+        title: 'Daily goal',
+        detail:
+          'Soft cap per exercise: hit N reps and that reminder goes quiet until tomorrow.',
+        tag: 'new'
+      },
+      {
+        title: 'Meeting auto-pause',
+        detail:
+          'No reminders while Zoom/Teams/Discord/Webex/Slack-huddle is running.',
+        tag: 'new'
+      },
+      {
+        title: 'Adaptive scheduling',
+        detail:
+          'Learns the hours you reliably do an exercise and shifts fires into those windows.',
+        tag: 'new'
+      },
+      {
+        title: 'Export & import',
+        detail:
+          'JSON backup of exercises, history and settings — for moving to another machine.',
+        tag: 'new'
+      },
+      {
+        title: "What's new screen",
+        detail: 'This screen. Opens automatically after an update.',
+        tag: 'new'
+      }
+    ]
+  },
+  '0.5.5': {
+    ru: [
+      {
+        title: 'Sandbox для окон',
+        detail: 'Окна изолированы на уровне OS — даже RCE в рендере не достанет main.',
+        tag: 'security'
+      },
+      {
+        title: 'Self-hosted шрифты',
+        detail:
+          'Plus Jakarta Sans + Bricolage Grotesque локально в bundle — работает без интернета.',
+        tag: 'security'
+      },
+      {
+        title: 'Логи для диагностики',
+        detail:
+          '%APPDATA%/Exercise Reminder/logs/latest.log — отдашь файл при проблеме.',
+        tag: 'new'
+      },
+      {
+        title: 'UI не залипает при retry-ях I/O',
+        tag: 'perf'
+      },
+      {
+        title: 'GSI больше не зависает на TIME_WAIT при выходе',
+        tag: 'fix'
+      }
+    ],
+    en: [
+      {
+        title: 'Window sandbox',
+        detail: 'OS-level isolation — even RCE in the renderer cannot reach main.',
+        tag: 'security'
+      },
+      {
+        title: 'Self-hosted fonts',
+        detail:
+          'Plus Jakarta Sans + Bricolage Grotesque shipped in-bundle — works offline.',
+        tag: 'security'
+      },
+      {
+        title: 'Diagnostic logs',
+        detail:
+          '%APPDATA%/Exercise Reminder/logs/latest.log — share it when something breaks.',
+        tag: 'new'
+      },
+      {
+        title: 'UI no longer freezes during I/O retries',
+        tag: 'perf'
+      },
+      {
+        title: 'GSI port no longer stuck in TIME_WAIT after exit',
+        tag: 'fix'
+      }
+    ]
+  },
+  '0.5.4': {
+    ru: [
+      {
+        title: 'Фоновое скачивание апдейта',
+        detail: 'Можно уйти на Dashboard и заниматься — апдейт качается в фоне.',
+        tag: 'new'
+      },
+      {
+        title: 'Моментальный рестарт',
+        detail: 'Кнопка «Рестарт» — ~1-2 сек до открытия новой версии, без диалогов NSIS.',
+        tag: 'new'
+      }
+    ],
+    en: [
+      {
+        title: 'Background update download',
+        detail: 'You can go to Dashboard and work — the update keeps downloading.',
+        tag: 'new'
+      },
+      {
+        title: 'Instant restart',
+        detail: 'Restart button — ~1-2 sec to the new version, no NSIS dialogs.',
+        tag: 'new'
+      }
+    ]
+  }
+}
+
+/**
+ * Возвращает версии, отсортированные desc, для которых есть заметки,
+ * с версиями, не виденными пользователем. Используется для «show whatsnew
+ * after update»: если пользователь прыгнул через несколько версий, показываем
+ * все пропущенные одним списком.
+ */
+export function unseenVersions(
+  current: string,
+  lastSeen: string | undefined
+): string[] {
+  const all = Object.keys(RELEASE_NOTES).sort(compareSemverDesc)
+  if (!lastSeen) {
+    // Первый запуск этого механизма — показываем только текущую версию
+    // чтобы не перегружать историей. Старые версии показывает только
+    // явный «What's new» из Settings.
+    return all.filter((v) => v === current)
+  }
+  return all.filter((v) => compareSemver(v, lastSeen) > 0 && compareSemver(v, current) <= 0)
+}
+
+function parseSemver(v: string): [number, number, number] {
+  const parts = v.split('.').map((n) => parseInt(n, 10))
+  return [parts[0] ?? 0, parts[1] ?? 0, parts[2] ?? 0]
+}
+
+function compareSemver(a: string, b: string): number {
+  const [a1, a2, a3] = parseSemver(a)
+  const [b1, b2, b3] = parseSemver(b)
+  if (a1 !== b1) return a1 - b1
+  if (a2 !== b2) return a2 - b2
+  return a3 - b3
+}
+
+function compareSemverDesc(a: string, b: string): number {
+  return -compareSemver(a, b)
+}

src/shared/types.test.ts

@@ -30,7 +30,11 @@ describe('SAMPLE_EXERCISES', () => {
       expect(ex.icon.length, `icon set for ${ex.name}`).toBeGreaterThan(0)
     }
   })
+
 })
+// NB: тест «sample icons ⊆ ICON_CHOICES» лежит в
+// src/renderer/src/lib/icon-choices.test.ts — он тянет renderer-сторону
+// (ICON_CHOICES), а node-tsconfig сюда не пускает renderer-импорты.
 
 describe('STAT_LABELS', () => {
   it('has a Russian label for every GameStat in every GAME_STATS bundle', () => {

src/shared/types.ts

@@ -1,3 +1,20 @@
+/**
+ * Категория напоминания. По умолчанию `exercise` — для совместимости со
+ * старыми state'ами (поле optional). Категория влияет на:
+ *  - tint иконки в карточке (hydration синий, eyes фиолетовый и т.д.)
+ *  - текст в окне напоминания («Время попить» вместо «Время тренировки»)
+ *  - подсчёт повторений: для hydration/eyes/posture `reps` обычно = 1
+ *    (это не «N раз», а просто «сделай»).
+ */
+export type ReminderCategory = 'exercise' | 'hydration' | 'eyes' | 'posture'
+
+export const REMINDER_CATEGORIES: ReminderCategory[] = [
+  'exercise',
+  'hydration',
+  'eyes',
+  'posture'
+]
+
 export type Exercise = {
   id: string
   name: string
@@ -7,6 +24,22 @@ export type Exercise = {
   enabled: boolean
   nextFireAt: number
   lastDoneAt?: number
+  /** Default 'exercise' если undefined — обратная совместимость. */
+  category?: ReminderCategory
+  /**
+   * Опциональная дневная цель в reps. Если задана, scheduler перестаёт
+   * fire'ить упражнение в течение дня, когда total reps за сегодня
+   * (учитывая actualReps в истории) достигают `dailyGoal`. Это «soft cap»
+   * поверх обычного interval'а: не меняет схему таймера, просто блокирует
+   * fires когда цель закрыта. Завтра счётчик обнуляется (по local day).
+   */
+  dailyGoal?: number
+  /**
+   * Адаптивный режим: scheduler анализирует исторические success/skip
+   * паттерны по часам и сдвигает fire'ы на «хорошие» часы. Не меняет
+   * базовый интервал — корректирует только timestamps.
+   */
+  adaptive?: boolean
 }
 
 export type NotificationMode = 'toast' | 'modal' | 'both'
@@ -30,6 +63,18 @@ export type Settings = {
   globalEnabled: boolean
   notificationMode: NotificationMode
   soundEnabled: boolean
+  /**
+   * TTS голос диктора в окне напоминания: «Время приседать. Десять раз».
+   * Полезно когда работаешь head-down (например пишешь код) — beep можно
+   * пропустить, голос — нет.
+   */
+  voicePromptsEnabled: boolean
+  /**
+   * Авто-пауза напоминаний во время ВКС-звонков. Сканирует список процессов
+   * (Zoom/Teams/Discord/Webex/Slack-huddle/etc) раз в 30 сек, если хоть один
+   * запущен — fires не происходят. Чисто Windows (через tasklist).
+   */
+  meetingAutoPause: boolean
   startWithWindows: boolean
   minimizeToTray: boolean
   startMinimized: boolean
@@ -37,25 +82,63 @@ export type Settings = {
   language: Language
   snoozeMinutes: number
   quietHours: QuietHours
+  /**
+   * Версия, для которой пользователь видел экран «Что нового». Если
+   * `app.getVersion()` отличается — модалка показывается при следующем
+   * запуске и записывает текущую версию.
+   */
+  lastSeenVersion?: string
 }
 
+/**
+ * State, видимое renderer'у (через IPC.getState и evtStateChanged).
+ * `history` намеренно НЕ включена — она достигает 10k записей × ~50 байт =
+ * 500KB JSON, и шлать её на каждый markDone/snooze/etc слишком дорого.
+ * Renderer запрашивает историю отдельно через `getHistory()` IPC (с опц.
+ * `sinceMs` для инкрементальной подгрузки).
+ */
 export type AppState = {
   exercises: Exercise[]
   settings: Settings
   challenges: Challenge[]
   gamesEnabled: Partial<Record<GameId, boolean>>
+}
+
+/** Persisted shape — расширяет AppState историей (живёт только в main). */
+export type PersistedState = AppState & {
   history?: HistoryEntry[]
 }
 
 export type HistoryAction = 'done' | 'skip' | 'snooze'
 
+/**
+ * Источник записи: обычное напоминание (от scheduler'а) или матч (челлендж).
+ * Используется для UI («подтянулся в матче» vs «по таймеру») и аналитики.
+ */
+export type HistorySource = 'reminder' | 'match'
+
 export type HistoryEntry = {
   /** ms epoch */
   ts: number
+  /**
+   * Для обычных напоминаний — Exercise.id. Для challenge'ей — `challenge:<id>`
+   * (синтетический ключ; renderer'у не нужно искать exercise по нему).
+   */
   exerciseId: string
   action: HistoryAction
   /** When user did less than planned. Only meaningful for `done`. */
   actualReps?: number
+  /**
+   * Snapshot повторений на момент записи. Гарантирует, что после удаления
+   * упражнения история не теряет «сколько было сделано» (раньше lookup
+   * `byId.get(exerciseId).reps` возвращал undefined → heatmap показывал 0).
+   * Для match-челленджей — фактическое число повторов из match summary.
+   */
+  reps?: number
+  /** Snapshot названия упражнения/челленджа — для будущего log-view. */
+  name?: string
+  /** undefined = reminder (для обратной совместимости со старыми entries). */
+  source?: HistorySource
 }
 
 export type Tick = {
@@ -162,6 +245,8 @@ export const DEFAULT_SETTINGS: Settings = {
   globalEnabled: true,
   notificationMode: 'modal',
   soundEnabled: true,
+  voicePromptsEnabled: false, // opt-in — на работе с коллегами может смущать
+  meetingAutoPause: true,
   startWithWindows: false,
   minimizeToTray: true,
   startMinimized: false,
@@ -235,21 +320,40 @@ export const SAMPLE_EXERCISES: Omit<Exercise, 'id' | 'nextFireAt'>[] = [
     reps: 10,
     icon: 'Activity',
     intervalMinutes: 30,
-    enabled: true
+    enabled: true,
+    category: 'exercise'
   },
   {
     name: 'Отжимания',
     reps: 10,
     icon: 'Dumbbell',
     intervalMinutes: 45,
-    enabled: true
+    enabled: true,
+    category: 'exercise'
   },
   {
-    name: 'Растяжка спины',
+    name: 'Стакан воды',
     reps: 1,
-    icon: 'StretchHorizontal',
+    icon: 'GlassWater',
     intervalMinutes: 60,
-    enabled: false
+    enabled: false,
+    category: 'hydration'
+  },
+  {
+    name: 'Отдых глазам (20-20-20)',
+    reps: 1,
+    icon: 'Eye',
+    intervalMinutes: 20,
+    enabled: false,
+    category: 'eyes'
+  },
+  {
+    name: 'Проверь осанку',
+    reps: 1,
+    icon: 'PersonStanding',
+    intervalMinutes: 25,
+    enabled: false,
+    category: 'posture'
   }
 ]