chore(release): v0.6.1

fix: harden reminders and state handling
fix(meals): плавная анимация переключателя в обе стороны
2026-06-06 12:37:53 +07:00 · 2026-06-06 02:27:04 +07:00 · 2026-06-06 00:13:07 +07:00 · 2026-06-05 22:16:52 +07:00 · 2026-06-03 23:45:34 +07:00
31 changed files with 3030 additions and 304 deletions
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -12,7 +12,7 @@
 - **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 теста, все зелёные)
+- **Тесты**: Vitest 4 (227 тестов, все зелёные)
 - **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)
@@ -68,6 +68,20 @@
 - Wrap-around (22:00 → 07:00) корректно — при wrap-active проверяется день *начала* окна
 - Тесты в `src/shared/quiet-hours.test.ts`

+### Питание / приёмы пищи (вкладка «Питание»)
+- **Отдельная модель `Meal`** (`src/shared/types.ts`): напоминание ПО ВРЕМЕНИ СУТОК
+  (`time` HH:MM + `days` weekdays), в отличие от interval-based `Exercise`
+- `nextMealOccurrence(time, days, fromMs)` — следующее срабатывание, календарная
+  арифметика (DST-safe, как history.ts). Тесты в `src/shared/meals.test.ts`
+- Scheduler `checkDueMeals()` (`src/main/scheduler.ts`): гейтит **только**
+  `globalEnabled` (НЕ тихие часы / НЕ ВКС — время задано пользователем явно).
+  Grace-окно `MEAL_GRACE_MS=120s`: приём, пропущенный давно (сон/выкл), тихо
+  переносится без срабатывания, чтобы не вывалить пачку напоминаний разом
+- Окно напоминания: `evtFireMeal` → `MealReminder` в `ReminderApp.tsx` (зелёный
+  акцент `bg-success`, кнопки «Поел» / «Отложить»)
+- Пресеты быстрого добавления — `MEAL_PRESETS` (имена через i18n-ключи)
+- Время валидируется строго (`validHHMM` в validate.ts — диапазон, не только форма)
+
 ### История / стрики
 - `src/renderer/src/lib/history.ts` — DST-safe через `shiftDays()` (calendar `setDate`, не ms-арифметика)
 - Cap 10k записей, trim oldest 10% на overflow
@@ -119,38 +133,41 @@ npm run release -- -Bump patch
 | `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/scheduler.ts` | таймеры упражнений (interval) + приёмы пищи (clock-time), 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` | окно напоминания |
+| `src/renderer/src/pages/Meals.tsx` + `components/MealEditor.tsx` | вкладка «Питание» |
+| `src/renderer/src/ReminderApp.tsx` | окно напоминания (упражнение / еда / матч) |

-## Тесты (203)
+## Тесты (227)

 ```
-src/main/validate.test.ts                (68)
+src/main/validate.test.ts                (78)
 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/scheduler.test.ts               (13)  ← main: gating + приёмы пищи
 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/shared/meals.test.ts                  (8)  ← nextMealOccurrence (DST-safe)
 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)
+src/renderer/src/lib/icon-choices.test.ts (4)
 ```

-Покрываются: IPC-валидация, persistence (миграции/карантин/cap), scheduler-gating
-(тихие часы/ВКС/daily-goal), детект ВКС (мок child_process), helpers, история/стрики
-(DST), тихие часы (wrap+filter), VDF-парсер Steam, достижения, i18n с плюрализацией,
-дефолты.
+Покрываются: IPC-валидация (упражнения/челленджи/приёмы пищи), persistence
+(миграции/карантин/cap), scheduler-gating (тихие часы/ВКС/daily-goal), планирование
+приёмов пищи по времени суток (DST-safe, grace-окно, игнор тихих часов), детект ВКС
+(мок child_process), helpers, история/стрики (DST), тихие часы (wrap+filter),
+VDF-парсер Steam, достижения, i18n с плюрализацией, дефолты.

 Паттерн для main-тестов: `vi.mock('electron'|'./store'|'node:child_process')` +
 `vi.resetModules()` + dynamic import (сброс module-level состояния между тестами).
--- a/README.md
+++ b/README.md
@@ -9,6 +9,7 @@ Windows desktop приложение, которое напоминает дел
 ## Что внутри

 - **Гибкие напоминания** — любое количество упражнений, интервал от минуты до часов, разные иконки.
+- **Питание** — отдельная вкладка с приёмами пищи по времени суток (завтрак/обед/ужин/перекусы), выбор дней недели, пресеты быстрого добавления. Напоминания по настенным часам, а не по интервалу.
 - **История и стрики** — heatmap-календарь активности, ежедневный счётчик, серия дней подряд.
 - **Тихие часы** — окно времени когда напоминания подавляются (например `22:00 → 08:00`), с выбором дней недели.
 - **Сделал частично** — степпер `−/+` в окне напоминания: если ты сделал 5 из 10, в историю запишется честное число.
@@ -66,25 +67,26 @@ npm run release -- -Bump patch    # bump версии + tag + push + upload в G
 ## Тесты

 ```
-src/main/validate.test.ts               (68)
+src/main/validate.test.ts                (78)
 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/scheduler.test.ts               (13)
 src/main/games/vdf.test.ts               (11)
 src/main/store.test.ts                   (10)
 src/renderer/src/lib/achievements.test.ts (10)
 src/shared/release-notes.test.ts          (9)
-src/main/scheduler.test.ts                (8)
+src/shared/meals.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)
+src/renderer/src/lib/icon-choices.test.ts (4)
 ──────────────────────────────────────────
-                                   203 ✓
+                                   227 ✓
 ```

-Покрытие: IPC-валидация, persistence (миграции, карантин битого JSON, history cap), scheduler-гейтинг (тихие часы, ВКС-пауза, daily-goal), детект ВКС, история/стрики (DST), тихие часы (wrap), парсер VDF для Steam-конфигов, достижения, i18n с плюрализацией RU/EN, дефолты shared-типов.
+Покрытие: IPC-валидация (упражнения/челленджи/приёмы пищи), persistence (миграции, карантин битого JSON, history cap), scheduler-гейтинг (тихие часы, ВКС-пауза, daily-goal), планирование приёмов пищи по времени суток (DST-safe), детект ВКС, история/стрики (DST), тихие часы (wrap), парсер VDF для Steam-конфигов, достижения, i18n с плюрализацией RU/EN, дефолты shared-типов.

 ## Лицензия

--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "laude",
-  "version": "0.5.8",
+  "version": "0.6.1",
  "description": "Exercise reminder — Windows desktop app",
  "main": "out/main/index.js",
  "author": "AnRil",
@@ -43,10 +43,12 @@
    "@typescript-eslint/eslint-plugin": "^8.15.0",
    "@typescript-eslint/parser": "^8.15.0",
    "@vitejs/plugin-react": "^4.3.3",
+    "@vitest/coverage-v8": "^4.1.6",
    "autoprefixer": "^10.4.20",
    "electron": "^33.2.0",
    "electron-builder": "^25.1.8",
    "electron-vite": "^2.3.0",
+    "esbuild": "^0.28.0",
    "eslint": "^8.57.1",
    "eslint-plugin-react": "^7.37.2",
    "eslint-plugin-react-hooks": "^5.0.0",
--- a/postcss.config.mjs
+++ b/postcss.config.mjs
--- a/scripts/release.ps1
+++ b/scripts/release.ps1
@@ -116,9 +116,6 @@ $pkgJson = [System.IO.File]::ReadAllText($pkgPath, $utf8NoBom)
 $pkgJson = $pkgJson -replace "`"version`":\s*`"$current`"", "`"version`": `"$next`""
 [System.IO.File]::WriteAllText($pkgPath, $pkgJson, $utf8NoBom)

-git add package.json
-git commit -m "chore(release): $tag"
-
 # --- Quality gates ------------------------------------------------------
 if (-not $SkipBuild) {
  Write-Host "Typecheck..." -ForegroundColor Cyan
@@ -145,6 +142,12 @@ foreach ($f in @($installer, $blockmap, $manifest)) {
  }
 }

+# Commit only after quality gates and artifact verification pass. If a check
+# fails, package.json remains modified but history does not get a broken
+# release commit/tag.
+git add package.json
+git commit -m "chore(release): $tag"
+
 # --- Tag + push ---------------------------------------------------------
 Write-Host "Tagging $tag and pushing..." -ForegroundColor Cyan
 git tag -a $tag -m "Release $tag"
--- a/src/main/games/registry.test.ts
+++ b/src/main/games/registry.test.ts
@@ -0,0 +1,119 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const h = vi.hoisted(() => ({
+  provider: {
+    displayName: 'Dota 2',
+    start: vi.fn(),
+    stop: vi.fn(),
+    detect: vi.fn(),
+    install: vi.fn(),
+    uninstall: vi.fn(),
+    reconcile: vi.fn()
+  },
+  startGsiServer: vi.fn(),
+  stopGsiServer: vi.fn(),
+  onLaunchOptionsApplied: vi.fn(),
+  gamesEnabled: { dota2: true },
+  fireMatchSummary: vi.fn(),
+  log: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() }
+}))
+
+vi.mock('electron', () => ({
+  BrowserWindow: { getAllWindows: () => [] }
+}))
+
+vi.mock('./dota2', () => ({
+  Dota2Provider: vi.fn(function Dota2Provider() {
+    return h.provider
+  })
+}))
+
+vi.mock('./gsi-server', () => ({
+  startGsiServer: h.startGsiServer,
+  stopGsiServer: h.stopGsiServer
+}))
+
+vi.mock('./steam-launch-options', () => ({
+  onLaunchOptionsApplied: h.onLaunchOptionsApplied
+}))
+
+vi.mock('../store', () => ({
+  getChallenges: () => [],
+  getGamesEnabled: () => h.gamesEnabled
+}))
+
+vi.mock('../notifications', () => ({
+  fireMatchSummary: h.fireMatchSummary
+}))
+
+vi.mock('../logger', () => ({
+  log: h.log
+}))
+
+async function loadRegistry(): Promise<typeof import('./registry')> {
+  return import('./registry')
+}
+
+beforeEach(() => {
+  vi.resetModules()
+  h.provider.start.mockResolvedValue(undefined)
+  h.provider.stop.mockResolvedValue(undefined)
+  h.provider.detect.mockResolvedValue({
+    id: 'dota2',
+    name: 'Dota 2',
+    installed: true,
+    integrationActive: true,
+    launchOptionStatus: 'applied',
+    enabled: true
+  })
+  h.provider.install.mockResolvedValue(undefined)
+  h.provider.uninstall.mockResolvedValue(undefined)
+  h.provider.reconcile.mockResolvedValue(undefined)
+  h.startGsiServer.mockReset()
+  h.startGsiServer.mockResolvedValue(undefined)
+  h.stopGsiServer.mockReset()
+  h.stopGsiServer.mockResolvedValue(undefined)
+  h.onLaunchOptionsApplied.mockClear()
+  h.fireMatchSummary.mockClear()
+  h.log.info.mockClear()
+  h.log.warn.mockClear()
+  h.log.error.mockClear()
+  h.log.debug.mockClear()
+})
+
+describe('games registry lifecycle', () => {
+  it('сбрасывает running после ошибки старта GSI и позволяет повторный старт', async () => {
+    h.startGsiServer
+      .mockRejectedValueOnce(new Error('port busy'))
+      .mockResolvedValueOnce(undefined)
+
+    const { startGamesRegistry } = await loadRegistry()
+    await startGamesRegistry()
+    await startGamesRegistry()
+
+    expect(h.startGsiServer).toHaveBeenCalledTimes(2)
+    expect(h.provider.start).toHaveBeenCalledTimes(1)
+  })
+
+  it('stopGamesRegistry ждёт полного shutdown GSI-сервера', async () => {
+    let releaseStop!: () => void
+    const stopPromise = new Promise<void>((resolve) => {
+      releaseStop = resolve
+    })
+    h.stopGsiServer.mockReturnValue(stopPromise)
+
+    const { startGamesRegistry, stopGamesRegistry } = await loadRegistry()
+    await startGamesRegistry()
+
+    let resolved = false
+    const pending = stopGamesRegistry().then(() => {
+      resolved = true
+    })
+    await Promise.resolve()
+
+    expect(resolved).toBe(false)
+    releaseStop()
+    await pending
+    expect(resolved).toBe(true)
+  })
+})
--- a/src/main/games/registry.ts
+++ b/src/main/games/registry.ts
@@ -87,6 +87,7 @@ export async function startGamesRegistry(): Promise<void> {
    await startGsiServer()
    log.info('[games] GSI server started on port 4701')
  } catch (err) {
+    running = false
    log.error('[games] GSI server failed to start', err)
    return
  }
@@ -119,7 +120,7 @@ export async function stopGamesRegistry(): Promise<void> {
  for (const id of Object.keys(providers) as GameId[]) {
    await providers[id].stop()
  }
-  stopGsiServer()
+  await stopGsiServer()
 }

 export async function listGamesStatus(): Promise<GameStatus[]> {
--- a/src/main/ipc.ts
+++ b/src/main/ipc.ts
@@ -14,9 +14,11 @@ import type { Exercise, GameId, Settings } from '@shared/types'
 import {
  addChallenge,
  addExercise,
+  addMeal,
  clearHistory,
  deleteChallenge,
  deleteExercise,
+  deleteMeal,
  exportState,
  getHistory,
  getState,
@@ -24,11 +26,13 @@ import {
  importState,
  markChallengeDone,
  markDone,
+  markMealDone,
  setGameEnabled,
  skip,
  snooze,
  updateChallenge,
  updateExercise,
+  updateMeal,
  updateSettings
 } from './store'
 import { broadcastHistoryChanged, broadcastState } from './state-actions'
@@ -58,6 +62,8 @@ import {
  validateExerciseInput,
  validateExercisePatch,
  validateId,
+  validateMealInput,
+  validateMealPatch,
  validateSettingsPatch,
  validateSnoozeMinutes
 } from './validate'
@@ -170,8 +176,10 @@ export function registerIpc(): void {
    const id = validateId(idRaw)
    if (!id) return null
    const ex = markDone(id, validateActualReps(repsRaw))
-    broadcastState()
-    broadcastHistoryChanged()
+    if (ex) {
+      broadcastState()
+      broadcastHistoryChanged()
+    }
    return ex
  })

@@ -180,8 +188,10 @@ export function registerIpc(): void {
    const minutes = validateSnoozeMinutes(minRaw)
    if (!id || minutes === null) return null
    const ex = snooze(id, minutes)
-    broadcastState()
-    broadcastHistoryChanged()
+    if (ex) {
+      broadcastState()
+      broadcastHistoryChanged()
+    }
    return ex
  })

@@ -189,11 +199,58 @@ export function registerIpc(): void {
    const id = validateId(idRaw)
    if (!id) return null
    const ex = skip(id)
-    broadcastState()
-    broadcastHistoryChanged()
+    if (ex) {
+      broadcastState()
+      broadcastHistoryChanged()
+    }
    return ex
  })

+  // Meals (приёмы пищи — напоминания по времени суток)
+  safeHandle(IPC.addMeal, (_e, input: unknown) => {
+    const safe = validateMealInput(input)
+    if (!safe) return null
+    const m = addMeal(safe)
+    broadcastState()
+    return m
+  })
+
+  safeHandle(IPC.updateMeal, (_e, idRaw: unknown, patchRaw: unknown) => {
+    const id = validateId(idRaw)
+    const patch = validateMealPatch(patchRaw)
+    if (!id || !patch) return null
+    const m = updateMeal(id, patch)
+    broadcastState()
+    return m
+  })
+
+  safeHandle(IPC.deleteMeal, (_e, idRaw: unknown) => {
+    const id = validateId(idRaw)
+    if (!id) return false
+    const ok = deleteMeal(id)
+    broadcastState()
+    return ok
+  })
+
+  safeHandle(IPC.toggleMeal, (_e, idRaw: unknown, enabledRaw: unknown) => {
+    const id = validateId(idRaw)
+    if (!id || typeof enabledRaw !== 'boolean') return null
+    const m = updateMeal(id, { enabled: enabledRaw })
+    broadcastState()
+    return m
+  })
+
+  safeHandle(IPC.markMealDone, (_e, idRaw: unknown) => {
+    const id = validateId(idRaw)
+    if (!id) return null
+    const m = markMealDone(id)
+    if (m) {
+      broadcastState()
+      broadcastHistoryChanged()
+    }
+    return m
+  })
+
  safeHandle(IPC.updateSettings, (_e, patchRaw: unknown) => {
    const patch = validateSettingsPatch(patchRaw)
    if (!patch) return null
--- a/src/main/meeting-detect.test.ts
+++ b/src/main/meeting-detect.test.ts
@@ -21,6 +21,8 @@ const h = vi.hoisted(() => ({
  log: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() }
 }))

+const originalPlatform = process.platform
+
 vi.mock('node:child_process', () => ({
  exec: (cmd: string, opts: unknown, cb: ExecCb) => {
    h.calls += 1
@@ -39,8 +41,16 @@ async function load(): Promise<typeof import('./meeting-detect')> {
  return import('./meeting-detect')
 }

+function setPlatform(platform: NodeJS.Platform): void {
+  Object.defineProperty(process, 'platform', {
+    value: platform,
+    configurable: true
+  })
+}
+
 beforeEach(() => {
  vi.resetModules()
+  setPlatform('win32')
  h.calls = 0
  h.execImpl = (_cmd, _opts, cb) => cb(null, { stdout: '' })
  h.log.info.mockClear()
@@ -48,6 +58,7 @@ beforeEach(() => {
 })

 afterEach(() => {
+  setPlatform(originalPlatform)
  vi.restoreAllMocks()
 })

@@ -96,14 +107,9 @@ describe('isMeetingActive', () => {
  })

  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 })
-    }
+    setPlatform('linux')
+    const { isMeetingActive } = await load()
+    expect(await isMeetingActive()).toBe(false)
+    expect(h.calls).toBe(0)
  })
 })
--- a/src/main/notifications.ts
+++ b/src/main/notifications.ts
@@ -1,5 +1,10 @@
 import { Notification, app } from 'electron'
-import type { Exercise, MatchSummary, NotificationMode } from '@shared/types'
+import type {
+  Exercise,
+  MatchSummary,
+  Meal,
+  NotificationMode
+} from '@shared/types'
 import { IPC } from '@shared/ipc'
 import {
  createReminderWindow,
@@ -12,6 +17,35 @@ export function fireReminder(exercise: Exercise, mode: NotificationMode): void {
  if (mode === 'modal' || mode === 'both') showModal(exercise)
 }

+export function fireMealReminder(meal: Meal, mode: NotificationMode): void {
+  if (mode === 'toast' || mode === 'both') showMealToast(meal)
+  if (mode === 'modal' || mode === 'both') showMealModal(meal)
+}
+
+function showMealToast(meal: Meal): void {
+  if (!Notification.isSupported()) return
+  const n = new Notification({
+    title: app.getName(),
+    body: meal.name,
+    silent: false
+  })
+  n.on('click', () => showReminderWindow())
+  n.show()
+}
+
+function showMealModal(meal: Meal): void {
+  const win = createReminderWindow()
+  const send = (): void => {
+    win.webContents.send(IPC.evtFireMeal, meal)
+  }
+  if (win.webContents.isLoading()) {
+    win.webContents.once('did-finish-load', send)
+  } else {
+    send()
+  }
+  showReminderWindow()
+}
+
 export function fireMatchSummary(summary: MatchSummary): void {
  if (Notification.isSupported()) {
    const totalReps = summary.results.reduce((s, r) => s + r.reps, 0)
--- a/src/main/scheduler.test.ts
+++ b/src/main/scheduler.test.ts
@@ -2,6 +2,7 @@ import { describe, it, expect, vi, beforeEach } from 'vitest'
 import type {
  Exercise,
  HistoryEntry,
+  Meal,
  QuietHours,
  Settings
 } from '@shared/types'
@@ -16,10 +17,13 @@ import { DEFAULT_SETTINGS } from '@shared/types'
 const h = vi.hoisted(() => ({
  settings: null as Settings | null,
  exercises: [] as Exercise[],
+  meals: [] as Meal[],
  history: [] as HistoryEntry[],
  meetingActive: false,
  fireReminder: vi.fn(),
+  fireMealReminder: vi.fn(),
  updateExercise: vi.fn(),
+  updateMeal: vi.fn(),
  broadcastState: vi.fn(),
  refreshMeetingState: vi.fn(),
  adjustNextFireAt: vi.fn((_ex: Exercise, candidate: number) => candidate)
@@ -32,14 +36,23 @@ vi.mock('electron', () => ({
 vi.mock('./store', () => ({
  getSettings: () => h.settings,
  getExercises: () => h.exercises,
+  getMeals: () => h.meals,
  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
+  },
+  updateMeal: (id: string, patch: Partial<Meal>) => {
+    h.updateMeal(id, patch)
+    const m = h.meals.find((e) => e.id === id)
+    return m ? { ...m, ...patch } : undefined
  }
 }))
-vi.mock('./notifications', () => ({ fireReminder: h.fireReminder }))
+vi.mock('./notifications', () => ({
+  fireReminder: h.fireReminder,
+  fireMealReminder: h.fireMealReminder
+}))
 vi.mock('./state-actions', () => ({ broadcastState: h.broadcastState }))
 vi.mock('./meeting-detect', () => ({
  isMeetingActiveSync: () => h.meetingActive,
@@ -78,14 +91,30 @@ async function loadScheduler(): Promise<typeof import('./scheduler')> {
  return import('./scheduler')
 }

+function makeMeal(over: Partial<Meal> = {}): Meal {
+  return {
+    id: 'm1',
+    name: 'Обед',
+    time: '13:00',
+    icon: 'Soup',
+    enabled: true,
+    days: [],
+    nextFireAt: Date.now() - 1000, // due, в пределах grace
+    ...over
+  }
+}
+
 beforeEach(() => {
  vi.resetModules()
  h.settings = { ...DEFAULT_SETTINGS }
  h.exercises = []
+  h.meals = []
  h.history = []
  h.meetingActive = false
  h.fireReminder.mockClear()
+  h.fireMealReminder.mockClear()
  h.updateExercise.mockClear()
+  h.updateMeal.mockClear()
  h.broadcastState.mockClear()
  h.refreshMeetingState.mockClear()
  h.adjustNextFireAt.mockClear()
@@ -157,6 +186,21 @@ describe('checkDueExercises gating', () => {
    expect(h.updateExercise).toHaveBeenCalled()
  })

+  it('dailyGoal использует reps snapshot из истории, а не текущие reps упражнения', async () => {
+    h.exercises = [makeExercise({ reps: 25, dailyGoal: 20 })]
+    h.history = [
+      {
+        ts: Date.now(),
+        exerciseId: 'ex1',
+        action: 'done',
+        reps: 10
+      }
+    ]
+    const { forceCheck } = await loadScheduler()
+    forceCheck()
+    expect(h.fireReminder).toHaveBeenCalledTimes(1)
+  })
+
  it('adaptive: применяет adjustNextFireAt к кандидату', async () => {
    h.exercises = [makeExercise({ adaptive: true })]
    const { forceCheck } = await loadScheduler()
@@ -165,3 +209,49 @@ describe('checkDueExercises gating', () => {
    expect(h.fireReminder).toHaveBeenCalledTimes(1)
  })
 })
+
+describe('checkDueMeals', () => {
+  it('fire-ит приём пищи, чьё время наступило (в пределах grace)', async () => {
+    h.meals = [makeMeal()]
+    const { forceCheck } = await loadScheduler()
+    forceCheck()
+    expect(h.fireMealReminder).toHaveBeenCalledTimes(1)
+    // Переносит nextFireAt вперёд.
+    expect(h.updateMeal).toHaveBeenCalled()
+  })
+
+  it('пропускает выключенный приём пищи', async () => {
+    h.meals = [makeMeal({ enabled: false })]
+    const { forceCheck } = await loadScheduler()
+    forceCheck()
+    expect(h.fireMealReminder).not.toHaveBeenCalled()
+  })
+
+  it('не fire-ит при globalEnabled=false', async () => {
+    h.settings = { ...DEFAULT_SETTINGS, globalEnabled: false }
+    h.meals = [makeMeal()]
+    const { forceCheck } = await loadScheduler()
+    forceCheck()
+    expect(h.fireMealReminder).not.toHaveBeenCalled()
+  })
+
+  it('пропущенный давно (> grace) переносится без срабатывания', async () => {
+    h.meals = [makeMeal({ nextFireAt: Date.now() - 10 * 60_000 })]
+    const { forceCheck } = await loadScheduler()
+    forceCheck()
+    expect(h.fireMealReminder).not.toHaveBeenCalled()
+    expect(h.updateMeal).toHaveBeenCalled() // всё равно переносим вперёд
+  })
+
+  it('приёмы пищи ИГНОРИРУЮТ тихие часы (в отличие от упражнений)', async () => {
+    h.settings = { ...DEFAULT_SETTINGS, quietHours: quietWindowAroundNow() }
+    h.exercises = [makeExercise()]
+    h.meals = [makeMeal()]
+    const { forceCheck } = await loadScheduler()
+    forceCheck()
+    // Упражнение подавлено тихими часами...
+    expect(h.fireReminder).not.toHaveBeenCalled()
+    // ...а приём пищи всё равно срабатывает.
+    expect(h.fireMealReminder).toHaveBeenCalledTimes(1)
+  })
+})
--- a/src/main/scheduler.ts
+++ b/src/main/scheduler.ts
@@ -1,16 +1,24 @@
 import { powerMonitor, BrowserWindow } from 'electron'
 import { IPC } from '@shared/ipc'
 import type { Exercise, Tick, HistoryEntry } from '@shared/types'
-import { isQuietAt } from '@shared/types'
-import { getExercises, getHistory, getSettings, updateExercise } from './store'
-import { fireReminder } from './notifications'
+import { isQuietAt, nextMealOccurrence } from '@shared/types'
+import {
+  getExercises,
+  getHistory,
+  getMeals,
+  getSettings,
+  updateExercise,
+  updateMeal
+} from './store'
+import { fireMealReminder, 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.
+ * Учитываем actualReps если задано (частичное выполнение), затем snapshot
+ * reps из истории, и только потом текущие planned reps упражнения.
 */
 function repsDoneToday(ex: Exercise, history: HistoryEntry[]): number {
  const todayKey = new Date()
@@ -21,7 +29,7 @@ function repsDoneToday(ex: Exercise, history: HistoryEntry[]): number {
    if (e.action !== 'done') continue
    if (e.exerciseId !== ex.id) continue
    if (e.ts < startMs) continue
-    sum += e.actualReps ?? ex.reps
+    sum += e.actualReps ?? e.reps ?? ex.reps
  }
  return sum
 }
@@ -95,6 +103,39 @@ function checkDueExercises(): void {
  if (anyFired) broadcastState()
 }

+/**
+ * Окно «опоздания»: приём пищи, чьё время прошло более чем на это, считаем
+ * пропущенным (ноут спал / приложение было выключено) и тихо переносим на
+ * следующее вхождение БЕЗ срабатывания — чтобы не вывалить пачку
+ * напоминаний разом при включении вечером. Чуть больше CHECK_MS с запасом.
+ */
+const MEAL_GRACE_MS = 120_000
+
+/**
+ * Приёмы пищи — по времени суток. В отличие от упражнений, НЕ подчиняются
+ * тихим часам и ВКС-паузе: пользователь явно задал время. Гейтит только
+ * глобальная пауза (globalEnabled). Срабатывает в пределах grace-окна после
+ * запланированного времени; в любом случае переносит nextFireAt вперёд.
+ */
+function checkDueMeals(): void {
+  const settings = getSettings()
+  if (!settings.globalEnabled) return
+  const now = Date.now()
+  let anyChanged = false
+  for (const meal of getMeals()) {
+    if (!meal.enabled) continue
+    if (meal.nextFireAt > now) continue
+    if (now - meal.nextFireAt <= MEAL_GRACE_MS) {
+      fireMealReminder(meal, settings.notificationMode)
+    }
+    updateMeal(meal.id, {
+      nextFireAt: nextMealOccurrence(meal.time, meal.days, now)
+    })
+    anyChanged = true
+  }
+  if (anyChanged) broadcastState()
+}
+
 function broadcastTicks(): void {
  const now = Date.now()
  const ticks: Tick[] = getExercises().map((e) => ({
@@ -113,6 +154,7 @@ function tick(): void {
  if (now - lastCheckAt >= CHECK_MS) {
    lastCheckAt = now
    checkDueExercises()
+    checkDueMeals()
  }
 }

--- a/src/main/store.test.ts
+++ b/src/main/store.test.ts
@@ -8,6 +8,7 @@ import {
 } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
+import { DEFAULT_SETTINGS } from '@shared/types'

 /**
 * Тесты persistence-слоя. Мокаем electron.app.getPath на временную директорию
@@ -147,6 +148,43 @@ describe('store · history cap', () => {
  })
 })

+describe('store · meal history', () => {
+  it('markMealDone пишет meal-entry в историю', async () => {
+    writeFileSync(
+      statePath(),
+      JSON.stringify({
+        exercises: [],
+        meals: [
+          {
+            id: 'm1',
+            name: 'Обед',
+            time: '13:00',
+            icon: 'Soup',
+            enabled: true,
+            days: [],
+            nextFireAt: Date.now() + 60_000
+          }
+        ],
+        challenges: [],
+        history: []
+      }),
+      'utf-8'
+    )
+
+    const { markMealDone, getHistory } = await load()
+    expect(markMealDone('m1')).toBeDefined()
+    expect(getHistory()).toMatchObject([
+      {
+        exerciseId: 'meal:m1',
+        action: 'done',
+        reps: 1,
+        name: 'Обед',
+        source: 'meal'
+      }
+    ])
+  })
+})
+
 describe('store · clearHistory', () => {
  it('удаляет записи старше границы и возвращает количество', async () => {
    const ex = {
@@ -195,4 +233,79 @@ describe('store · export / import', () => {
    expect(importState('not json at all')).toBe(false)
    expect(importState('42')).toBe(false)
  })
+
+  it('import сохраняет валидные части snapshot и отбрасывает повреждённые записи', async () => {
+    const validExercise = {
+      id: 'x1',
+      name: 'Тест',
+      reps: 10,
+      icon: 'Activity',
+      intervalMinutes: 30,
+      enabled: true,
+      nextFireAt: Date.now() + 1000
+    }
+    const validMeal = {
+      id: 'm1',
+      name: 'Обед',
+      time: '13:00',
+      icon: 'Soup',
+      enabled: true,
+      days: [],
+      nextFireAt: Date.now() + 1000
+    }
+    const validChallenge = {
+      id: 'c1',
+      name: 'За убийства',
+      gameId: 'dota2',
+      stat: 'kills',
+      multiplier: 1,
+      exerciseName: 'Отжимания',
+      icon: 'Dumbbell',
+      enabled: true
+    }
+
+    const { importState, getState, getSettings, getHistory } = await load()
+    expect(
+      importState(
+        JSON.stringify({
+          exercises: [
+            validExercise,
+            { ...validExercise, id: 'bad-ex', intervalMinutes: -5 }
+          ],
+          meals: [validMeal, { ...validMeal, id: 'bad-meal', time: '25:00' }],
+          settings: {
+            globalEnabled: false,
+            snoozeMinutes: -1,
+            language: 'xx'
+          },
+          challenges: [
+            validChallenge,
+            { ...validChallenge, id: 'bad-challenge', gameId: 'cs2' }
+          ],
+          gamesEnabled: { dota2: true, cs2: true },
+          history: [
+            { ts: 100, exerciseId: 'x1', action: 'done', reps: 10 },
+            { ts: -1, exerciseId: 'x1', action: 'done', reps: 10 },
+            {
+              ts: 200,
+              exerciseId: 'meal:m1',
+              action: 'done',
+              reps: 1,
+              source: 'meal'
+            }
+          ]
+        })
+      )
+    ).toBe(true)
+
+    const state = getState()
+    expect(state.exercises.map((e) => e.id)).toEqual(['x1'])
+    expect(state.meals.map((m) => m.id)).toEqual(['m1'])
+    expect(state.challenges.map((c) => c.id)).toEqual(['c1'])
+    expect(state.gamesEnabled).toEqual({ dota2: true })
+    expect(getHistory().map((e) => e.ts)).toEqual([100, 200])
+    expect(getSettings().globalEnabled).toBe(false)
+    expect(getSettings().snoozeMinutes).toBe(DEFAULT_SETTINGS.snoozeMinutes)
+    expect(getSettings().language).toBe(DEFAULT_SETTINGS.language)
+  })
 })
--- a/src/main/store.ts
+++ b/src/main/store.ts
@@ -17,11 +17,22 @@ import {
  GameId,
  HistoryAction,
  HistoryEntry,
+  HistorySource,
+  Meal,
+  nextMealOccurrence,
  PersistedState,
  SAMPLE_EXERCISES,
+  SAMPLE_MEALS,
  Settings
 } from '@shared/types'
 import { log } from './logger'
+import {
+  validateChallengeInput,
+  validateExerciseInput,
+  validateId,
+  validateMealInput,
+  validateSettingsPatch
+} from './validate'

 /**
 * Keep at most this many history entries (≈2.7 years at 10/day).
@@ -53,6 +64,11 @@ function makeInitial(): PersistedState {
      id: randomUUID(),
      nextFireAt: now + e.intervalMinutes * 60_000
    })),
+    meals: SAMPLE_MEALS.map((m) => ({
+      ...m,
+      id: randomUUID(),
+      nextFireAt: nextMealOccurrence(m.time, m.days, now)
+    })),
    settings: { ...DEFAULT_SETTINGS },
    challenges: [
      {
@@ -102,6 +118,136 @@ function isValidParsed(v: unknown): v is Record<string, unknown> {
  return typeof v === 'object' && v !== null && !Array.isArray(v)
 }

+function finiteMs(v: unknown): number | undefined {
+  return typeof v === 'number' &&
+    Number.isFinite(v) &&
+    v >= 0 &&
+    v <= Number.MAX_SAFE_INTEGER
+    ? v
+    : undefined
+}
+
+function intInRange(v: unknown, min: number, max: number): number | undefined {
+  if (typeof v !== 'number' || !Number.isFinite(v)) return undefined
+  const n = Math.trunc(v)
+  return n >= min && n <= max ? n : undefined
+}
+
+function safeStr(v: unknown, max = 200): string | undefined {
+  if (typeof v !== 'string') return undefined
+  if (v.length === 0 || v.length > max) return undefined
+  return v
+}
+
+const SETTINGS_KEYS: (keyof Settings)[] = [
+  'globalEnabled',
+  'notificationMode',
+  'soundEnabled',
+  'voicePromptsEnabled',
+  'meetingAutoPause',
+  'startWithWindows',
+  'minimizeToTray',
+  'startMinimized',
+  'theme',
+  'language',
+  'snoozeMinutes',
+  'quietHours',
+  'lastSeenVersion'
+]
+
+const GAME_IDS: GameId[] = ['dota2']
+const HISTORY_ACTIONS: HistoryAction[] = ['done', 'skip', 'snooze']
+const HISTORY_SOURCES: HistorySource[] = ['reminder', 'meal', 'match']
+
+function sanitizeSettings(raw: unknown): Settings {
+  const out: Settings = { ...DEFAULT_SETTINGS }
+  if (!isValidParsed(raw)) return out
+
+  for (const key of SETTINGS_KEYS) {
+    if (!(key in raw)) continue
+    const patch = validateSettingsPatch({ [key]: raw[key] })
+    if (patch) Object.assign(out, patch)
+  }
+
+  return out
+}
+
+function sanitizeExercise(raw: unknown, now = Date.now()): Exercise | null {
+  if (!isValidParsed(raw)) return null
+  const id = validateId(raw.id)
+  const base = validateExerciseInput(raw)
+  if (!id || !base) return null
+
+  const exercise: Exercise = {
+    ...base,
+    id,
+    nextFireAt: finiteMs(raw.nextFireAt) ?? now + base.intervalMinutes * 60_000
+  }
+  const lastDoneAt = finiteMs(raw.lastDoneAt)
+  if (lastDoneAt !== undefined) exercise.lastDoneAt = lastDoneAt
+  return exercise
+}
+
+function sanitizeMeal(raw: unknown, now = Date.now()): Meal | null {
+  if (!isValidParsed(raw)) return null
+  const id = validateId(raw.id)
+  const base = validateMealInput(raw)
+  if (!id || !base) return null
+
+  const meal: Meal = {
+    ...base,
+    id,
+    nextFireAt: finiteMs(raw.nextFireAt) ?? nextMealOccurrence(base.time, base.days, now)
+  }
+  const lastDoneAt = finiteMs(raw.lastDoneAt)
+  if (lastDoneAt !== undefined) meal.lastDoneAt = lastDoneAt
+  return meal
+}
+
+function sanitizeChallenge(raw: unknown): Challenge | null {
+  if (!isValidParsed(raw)) return null
+  const id = validateId(raw.id)
+  const base = validateChallengeInput(raw)
+  if (!id || !base) return null
+  return { ...base, id }
+}
+
+function sanitizeGamesEnabled(raw: unknown): Partial<Record<GameId, boolean>> {
+  const out: Partial<Record<GameId, boolean>> = {}
+  if (!isValidParsed(raw)) return out
+  for (const id of GAME_IDS) {
+    if (typeof raw[id] === 'boolean') out[id] = raw[id]
+  }
+  return out
+}
+
+function sanitizeHistoryEntry(raw: unknown): HistoryEntry | null {
+  if (!isValidParsed(raw)) return null
+  const ts = finiteMs(raw.ts)
+  const exerciseId = validateId(raw.exerciseId)
+  const action =
+    typeof raw.action === 'string' &&
+    HISTORY_ACTIONS.includes(raw.action as HistoryAction)
+      ? (raw.action as HistoryAction)
+      : undefined
+  if (ts === undefined || !exerciseId || action === undefined) return null
+
+  const entry: HistoryEntry = { ts, exerciseId, action }
+  const actualReps = intInRange(raw.actualReps, 0, 100_000)
+  if (actualReps !== undefined) entry.actualReps = actualReps
+  const reps = intInRange(raw.reps, 0, 100_000)
+  if (reps !== undefined) entry.reps = reps
+  const name = safeStr(raw.name)
+  if (name !== undefined) entry.name = name
+  if (
+    typeof raw.source === 'string' &&
+    HISTORY_SOURCES.includes(raw.source as HistorySource)
+  ) {
+    entry.source = raw.source as HistorySource
+  }
+  return entry
+}
+
 /**
 * Current persisted-state schema version. Bump this and add a migration to
 * MIGRATIONS whenever the on-disk shape changes in a non-additive way.
@@ -147,19 +293,36 @@ function runMigrations(s: StoredState): StoredState {

 /** Coerce a (possibly partial) migrated state into a fully-formed PersistedState. */
 function coerce(s: StoredState): PersistedState {
+  const now = Date.now()
  return {
-    exercises: Array.isArray(s.exercises) ? (s.exercises as Exercise[]) : [],
-    settings: {
-      ...DEFAULT_SETTINGS,
-      ...(isValidParsed(s.settings) ? (s.settings as Partial<Settings>) : {})
-    },
-    challenges: Array.isArray(s.challenges)
-      ? (s.challenges as Challenge[])
+    exercises: Array.isArray(s.exercises)
+      ? s.exercises.flatMap((raw) => {
+          const exercise = sanitizeExercise(raw, now)
+          return exercise ? [exercise] : []
+        })
      : [],
-    gamesEnabled: isValidParsed(s.gamesEnabled)
-      ? (s.gamesEnabled as Partial<Record<GameId, boolean>>)
-      : {},
-    history: Array.isArray(s.history) ? (s.history as HistoryEntry[]) : []
+    // Additive: старые state'ы без `meals` получают пустой список (см. философию
+    // миграций — additive-поля не требуют bump'а схемы).
+    meals: Array.isArray(s.meals)
+      ? s.meals.flatMap((raw) => {
+          const meal = sanitizeMeal(raw, now)
+          return meal ? [meal] : []
+        })
+      : [],
+    settings: sanitizeSettings(s.settings),
+    challenges: Array.isArray(s.challenges)
+      ? s.challenges.flatMap((raw) => {
+          const challenge = sanitizeChallenge(raw)
+          return challenge ? [challenge] : []
+        })
+      : [],
+    gamesEnabled: sanitizeGamesEnabled(s.gamesEnabled),
+    history: Array.isArray(s.history)
+      ? s.history.flatMap((raw) => {
+          const entry = sanitizeHistoryEntry(raw)
+          return entry ? [entry] : []
+        })
+      : []
  }
 }

@@ -360,6 +523,7 @@ export function getStateForRenderer(): AppState {
  const p = getState()
  return {
    exercises: p.exercises,
+    meals: p.meals,
    settings: p.settings,
    challenges: p.challenges,
    gamesEnabled: p.gamesEnabled
@@ -467,6 +631,79 @@ export function skip(id: string): Exercise | undefined {
  return ex
 }

+// -------------------------------------------------------------------------
+// Meals (приёмы пищи — по времени суток)
+// -------------------------------------------------------------------------
+
+export function getMeals(): Meal[] {
+  return getState().meals
+}
+
+export function addMeal(
+  input: Omit<Meal, 'id' | 'nextFireAt' | 'lastDoneAt'>
+): Meal {
+  const state = getState()
+  const meal: Meal = {
+    ...input,
+    id: randomUUID(),
+    nextFireAt: nextMealOccurrence(input.time, input.days, Date.now())
+  }
+  state.meals.push(meal)
+  scheduleWrite()
+  return meal
+}
+
+export function updateMeal(
+  id: string,
+  patch: Partial<Omit<Meal, 'id'>>
+): Meal | undefined {
+  const state = getState()
+  const idx = state.meals.findIndex((m) => m.id === id)
+  if (idx === -1) return undefined
+  const merged: Meal = { ...state.meals[idx], ...patch }
+  // Если поменялось время/дни/вкл — и nextFireAt не задан явно — пересчитать
+  // следующее срабатывание (toggle-on тоже сюда попадает).
+  if (
+    (patch.time !== undefined ||
+      patch.days !== undefined ||
+      patch.enabled !== undefined) &&
+    patch.nextFireAt === undefined
+  ) {
+    merged.nextFireAt = nextMealOccurrence(merged.time, merged.days, Date.now())
+  }
+  state.meals[idx] = merged
+  scheduleWrite()
+  return merged
+}
+
+export function deleteMeal(id: string): boolean {
+  const state = getState()
+  const before = state.meals.length
+  state.meals = state.meals.filter((m) => m.id !== id)
+  const ok = state.meals.length < before
+  if (ok) scheduleWrite()
+  return ok
+}
+
+export function markMealDone(id: string): Meal | undefined {
+  const state = getState()
+  const meal = state.meals.find((m) => m.id === id)
+  if (!meal) return undefined
+  meal.lastDoneAt = Date.now()
+  // nextFireAt обычно уже перенесён планировщиком в момент срабатывания;
+  // подстраховка на случай ручного вызова — гарантируем будущее время.
+  if (meal.nextFireAt <= Date.now()) {
+    meal.nextFireAt = nextMealOccurrence(meal.time, meal.days, Date.now())
+  }
+  appendHistory(`meal:${id}`, 'done', {
+    reps: 1,
+    name: meal.name,
+    source: 'meal'
+  })
+  scheduleWrite()
+  return meal
+}
+
 /**
 * Записать выполнение челленджа из match summary в историю. Не привязано
 * к конкретному Exercise (челлендж может ссылаться на упражнение, которое
@@ -561,8 +798,8 @@ export function exportState(): string {

 /**
 * Импорт snapshot'а. Перезаписывает текущий state. Возвращает true при
- * успехе. Идёт через тот же coerce + runMigrations что и load() — это
- * валидирует тип/диапазоны.
+ * успехе. Идёт через тот же coerce + runMigrations что и load(): валидные
+ * записи сохраняются, повреждённые записи/поля отбрасываются.
 *
 * НЕ объединяет с текущим state (merge сложен: дубликаты id, конфликты
 * settings) — простое replace. Перед импортом UI должен спросить
--- a/src/main/validate.test.ts
+++ b/src/main/validate.test.ts
@@ -18,12 +18,90 @@ import {
  validateExercisePatch,
  validateChallengeInput,
  validateChallengePatch,
+  validateMealInput,
+  validateMealPatch,
  validateSettingsPatch,
  validateId,
  validateActualReps,
  validateSnoozeMinutes
 } from './validate'

+describe('validateMealInput', () => {
+  it('принимает валидный приём пищи', () => {
+    const r = validateMealInput({
+      name: 'Обед',
+      time: '13:00',
+      icon: 'Soup',
+      enabled: true,
+      days: [1, 2, 3, 4, 5]
+    })
+    expect(r).toEqual({
+      name: 'Обед',
+      time: '13:00',
+      icon: 'Soup',
+      enabled: true,
+      days: [1, 2, 3, 4, 5]
+    })
+  })
+
+  it('дефолтит icon и enabled', () => {
+    const r = validateMealInput({ name: 'Ужин', time: '19:00', days: [] })
+    expect(r?.icon).toBe('UtensilsCrossed')
+    expect(r?.enabled).toBe(true)
+  })
+
+  it('реджектит без имени / времени', () => {
+    expect(validateMealInput({ time: '13:00', days: [] })).toBeNull()
+    expect(validateMealInput({ name: 'X', days: [] })).toBeNull()
+  })
+
+  it('реджектит кривое время', () => {
+    expect(
+      validateMealInput({ name: 'X', time: '99:99', days: [] })
+    ).toBeNull()
+    expect(
+      validateMealInput({ name: 'X', time: 'noon', days: [] })
+    ).toBeNull()
+  })
+
+  it('реджектит дни вне диапазона и дедупит', () => {
+    expect(
+      validateMealInput({ name: 'X', time: '13:00', days: [7] })
+    ).toBeNull()
+    const r = validateMealInput({
+      name: 'X',
+      time: '13:00',
+      days: [1, 1, 2]
+    })
+    expect(r?.days).toEqual([1, 2])
+  })
+
+  it('реджектит не-объект', () => {
+    expect(validateMealInput(null)).toBeNull()
+    expect(validateMealInput('meal')).toBeNull()
+  })
+})
+
+describe('validateMealPatch', () => {
+  it('частичный патч только заданных полей', () => {
+    expect(validateMealPatch({ time: '07:30' })).toEqual({ time: '07:30' })
+    expect(validateMealPatch({ enabled: false })).toEqual({ enabled: false })
+  })
+
+  it('реджектит кривое время в патче', () => {
+    expect(validateMealPatch({ time: '25:00' })).toBeNull()
+  })
+
+  it('пропускает scheduler-поля с range-check', () => {
+    expect(validateMealPatch({ nextFireAt: 123 })).toEqual({ nextFireAt: 123 })
+    expect(validateMealPatch({ nextFireAt: -1 })).toBeNull()
+  })
+
+  it('реджектит кривые дни', () => {
+    expect(validateMealPatch({ days: [0, 8] })).toBeNull()
+  })
+})
+
 const validExercise = {
  name: 'Push-ups',
  reps: 10,
--- a/src/main/validate.ts
+++ b/src/main/validate.ts
@@ -14,7 +14,9 @@
 import type {
  Challenge,
  Exercise,
+  GameId,
  GameStat,
+  Meal,
  Settings,
  Theme,
  Language,
@@ -26,6 +28,7 @@ const MAX_STR_LEN = 200
 const VALID_THEMES: Theme[] = ['system', 'light', 'dark']
 const VALID_LANGS: Language[] = ['ru', 'en']
 const VALID_NOTIFY: NotificationMode[] = ['toast', 'modal', 'both']
+const VALID_GAME_IDS: GameId[] = ['dota2']
 const VALID_STATS: GameStat[] = [
  'deaths',
  'kills',
@@ -78,6 +81,34 @@ function oneOf<T extends string>(
    : undefined
 }

+/**
+ * Строгая проверка "HH:MM": не только форма, но и диапазон (часы 0..23,
+ * минуты 0..59). В отличие от HHMM_RE (используется в quietHours лишь для
+ * формы) — приём пищи с временем '25:00' сломал бы nextMealOccurrence.
+ */
+function validHHMM(v: unknown): string | undefined {
+  const s = safeStr(v, 8)
+  if (s === undefined) return undefined
+  const m = /^(\d{1,2}):(\d{2})$/.exec(s)
+  if (!m) return undefined
+  const h = Number(m[1])
+  const min = Number(m[2])
+  if (h > 23 || min > 59) return undefined
+  return s
+}
+
+/** Дни недели: массив целых 0..6 без дубликатов. null = невалидно. */
+function weekdays(v: unknown): number[] | null {
+  if (!Array.isArray(v)) return null
+  const out: number[] = []
+  for (const d of v) {
+    const n = intInRange(d, 0, 6)
+    if (n === undefined) return null
+    if (!out.includes(n)) out.push(n)
+  }
+  return out
+}
+
 // -----------------------------------------------------------------------
 // Exercise validators
 // -----------------------------------------------------------------------
@@ -188,6 +219,69 @@ export function validateExercisePatch(
  return out
 }

+// -----------------------------------------------------------------------
+// Meal validators (приёмы пищи — по времени суток)
+// -----------------------------------------------------------------------
+
+export function validateMealInput(
+  raw: unknown
+): Omit<Meal, 'id' | 'nextFireAt' | 'lastDoneAt'> | null {
+  if (!isObj(raw)) return null
+  const name = safeStr(raw.name)
+  const time = validHHMM(raw.time)
+  const icon = safeStr(raw.icon, 64) ?? 'UtensilsCrossed'
+  const enabled = bool(raw.enabled) ?? true
+  const days = weekdays(raw.days)
+  if (name === undefined || time === undefined || days === null) {
+    return null
+  }
+  return { name, time, icon, enabled, days }
+}
+
+export function validateMealPatch(
+  raw: unknown
+): Partial<Omit<Meal, 'id'>> | null {
+  if (!isObj(raw)) return null
+  const out: Partial<Omit<Meal, 'id'>> = {}
+  if ('name' in raw) {
+    const v = safeStr(raw.name)
+    if (v === undefined) return null
+    out.name = v
+  }
+  if ('time' in raw) {
+    const v = validHHMM(raw.time)
+    if (v === undefined) return null
+    out.time = v
+  }
+  if ('icon' in raw) {
+    const v = safeStr(raw.icon, 64)
+    if (v === undefined) return null
+    out.icon = v
+  }
+  if ('enabled' in raw) {
+    const v = bool(raw.enabled)
+    if (v === undefined) return null
+    out.enabled = v
+  }
+  if ('days' in raw) {
+    const v = weekdays(raw.days)
+    if (v === null) return null
+    out.days = v
+  }
+  // Scheduler-controlled fields (store reschedules через тот же boundary).
+  if ('nextFireAt' in raw) {
+    const v = numInRange(raw.nextFireAt, 0, Number.MAX_SAFE_INTEGER)
+    if (v === undefined) return null
+    out.nextFireAt = v
+  }
+  if ('lastDoneAt' in raw) {
+    const v = numInRange(raw.lastDoneAt, 0, Number.MAX_SAFE_INTEGER)
+    if (v === undefined) return null
+    out.lastDoneAt = v
+  }
+  return out
+}
+
 // -----------------------------------------------------------------------
 // Challenge validators
 // -----------------------------------------------------------------------
@@ -197,7 +291,7 @@ export function validateChallengeInput(
 ): Omit<Challenge, 'id'> | null {
  if (!isObj(raw)) return null
  const name = safeStr(raw.name)
-  const gameId = safeStr(raw.gameId, 32)
+  const gameId = oneOf(raw.gameId, VALID_GAME_IDS)
  const stat = oneOf(raw.stat, VALID_STATS)
  const multiplier = numInRange(raw.multiplier, 0, 1000)
  const exerciseName = safeStr(raw.exerciseName)
@@ -214,7 +308,7 @@ export function validateChallengeInput(
  }
  return {
    name,
-    gameId: gameId as Challenge['gameId'],
+    gameId,
    stat,
    multiplier,
    exerciseName,
--- a/src/preload/index.ts
+++ b/src/preload/index.ts
@@ -8,6 +8,7 @@ import type {
  GameStatus,
  HistoryEntry,
  MatchSummary,
+  Meal,
  Settings,
  Tick,
  UpdaterStatus
@@ -41,6 +42,19 @@ const api = {
    ipcRenderer.invoke(IPC.snooze, id, minutes),
  skip: (id: string): Promise<Exercise> => ipcRenderer.invoke(IPC.skip, id),

+  // Meals
+  addMeal: (
+    input: Omit<Meal, 'id' | 'nextFireAt' | 'lastDoneAt'>
+  ): Promise<Meal> => ipcRenderer.invoke(IPC.addMeal, input),
+  updateMeal: (id: string, patch: Partial<Meal>): Promise<Meal> =>
+    ipcRenderer.invoke(IPC.updateMeal, id, patch),
+  deleteMeal: (id: string): Promise<boolean> =>
+    ipcRenderer.invoke(IPC.deleteMeal, id),
+  toggleMeal: (id: string, enabled: boolean): Promise<Meal> =>
+    ipcRenderer.invoke(IPC.toggleMeal, id, enabled),
+  markMealDone: (id: string): Promise<Meal> =>
+    ipcRenderer.invoke(IPC.markMealDone, id),
+
  updateSettings: (patch: Partial<Settings>): Promise<Settings> =>
    ipcRenderer.invoke(IPC.updateSettings, patch),

@@ -136,6 +150,7 @@ const api = {

  onTick: (h: Handler<Tick[]>): Unsub => on(IPC.evtTick, h),
  onFire: (h: Handler<Exercise>): Unsub => on(IPC.evtFire, h),
+  onFireMeal: (h: Handler<Meal>): Unsub => on(IPC.evtFireMeal, h),
  onMatchEnd: (h: Handler<MatchSummary>): Unsub => on(IPC.evtMatchEnd, h),
  onStateChanged: (h: Handler<AppState>): Unsub => on(IPC.evtStateChanged, h),
  onThemeChanged: (h: Handler<'light' | 'dark'>): Unsub =>
--- a/src/renderer/src/App.tsx
+++ b/src/renderer/src/App.tsx
@@ -9,6 +9,7 @@ import { Skeleton } from './components/ui/Skeleton'
 import { unseenVersions } from '@shared/release-notes'
 import Dashboard from './pages/Dashboard'
 import Exercises from './pages/Exercises'
+import Meals from './pages/Meals'
 import GamesPage from './pages/Games'
 import ChallengesPage from './pages/Challenges'
 import SettingsPage from './pages/Settings'
@@ -152,6 +153,7 @@ function RoutedPages({ onNav }: { onNav: () => void }): JSX.Element {
        <Routes location={location}>
          <Route path="/" element={<Dashboard />} />
          <Route path="/exercises" element={<Exercises />} />
+          <Route path="/meals" element={<Meals />} />
          <Route path="/games" element={<GamesPage />} />
          <Route path="/challenges" element={<ChallengesPage />} />
          <Route path="/settings" element={<SettingsPage />} />
--- a/src/renderer/src/ReminderApp.tsx
+++ b/src/renderer/src/ReminderApp.tsx
@@ -13,6 +13,7 @@ import {
 import type {
  Exercise,
  MatchSummary,
+  Meal,
  Settings,
  ChallengeResult,
  Language
@@ -26,8 +27,11 @@ import { translate, translateN } from './i18n'
 type Mode =
  | { kind: 'idle' }
  | { kind: 'exercise'; exercise: Exercise }
+  | { kind: 'meal'; meal: Meal }
  | { kind: 'match'; summary: MatchSummary; done: Set<string> }

+type ActiveMode = Exclude<Mode, { kind: 'idle' }>
+
 /** Минимальный нативный confirm. В reminder-окне нет места для модалки,
 * проще использовать встроенный диалог. */
 function nativeConfirm(message: string): boolean {
@@ -39,6 +43,8 @@ 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)
+  const modeRef = useRef<Mode>({ kind: 'idle' })
+  const queueRef = useRef<ActiveMode[]>([])
  // ChallengeId'ы, для которых уже отправили markChallengeDone IPC. ref,
  // не state — нужен только для дедупа rapid double-click. Сбрасывается
  // когда приходит новый match summary (см. onMatchEnd ниже).
@@ -48,48 +54,31 @@ export default function ReminderApp(): JSX.Element {
    settingsRef.current = settings
  }, [settings])

+  useEffect(() => {
+    modeRef.current = mode
+  }, [mode])
+
  useEffect(() => {
    window.api.getState().then((s) => setSettings(s.settings))
    const u0 = window.api.onStateChanged((s) => setSettings(s.settings))
    const u1 = window.api.onFire((ex) => {
-      setMode({ kind: 'exercise', exercise: ex })
-      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)
-      }
+      enqueueMode({ kind: 'exercise', exercise: ex })
+    })
+    const u1b = window.api.onFireMeal((meal) => {
+      enqueueMode({ kind: 'meal', meal })
    })
    const u2 = window.api.onMatchEnd((summary) => {
-      // Новый матч — сбрасываем дедуп challenge'ей.
-      sentChallengesRef.current = new Set()
-      setMode({ kind: 'match', summary, done: new Set() })
-      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)
-      }
+      enqueueMode({ kind: 'match', summary, done: new Set() })
    })
    return () => {
      u0()
      u1()
+      u1b()
      u2()
    }
+    // IPC-подписки должны жить один раз; enqueueMode читает актуальный mode
+    // через ref, поэтому зависимость здесь не нужна.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [])

  // ESC closes the match summary view too — keyboard parity with exercise mode.
@@ -103,6 +92,63 @@ export default function ReminderApp(): JSX.Element {
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [mode.kind])

+  function enqueueMode(next: ActiveMode): void {
+    if (modeRef.current.kind === 'idle') {
+      activateMode(next)
+      return
+    }
+    queueRef.current.push(next)
+  }
+
+  function activateMode(next: ActiveMode): void {
+    if (next.kind === 'match') {
+      // Новый match summary получает чистый дедуп-сет только когда реально
+      // становится активным; иначе queued summary не сбивает текущий матч.
+      sentChallengesRef.current = new Set()
+    }
+    modeRef.current = next
+    setMode(next)
+    playAlertFor(next)
+  }
+
+  function playAlertFor(next: ActiveMode): void {
+    const s = settingsRef.current
+    if (s?.soundEnabled) playBeep()
+    if (!s?.voicePromptsEnabled) return
+
+    const lang = s.language ?? 'ru'
+    if (next.kind === 'exercise') {
+      const ex = next.exercise
+      // Задержка 800ms даёт пользователю шанс decrement'нуть stepper до
+      // фактического количества — TTS прозвучит уже под реальную цифру,
+      // если успел нажать -. Иначе скажет планируемые reps.
+      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)
+      return
+    }
+
+    if (next.kind === 'meal') {
+      const phrase =
+        lang === 'ru'
+          ? `Пора поесть. ${next.meal.name}`
+          : `Time to eat. ${next.meal.name}`
+      speak(phrase, lang)
+      return
+    }
+
+    const total = next.summary.results.reduce((acc, r) => acc + r.reps, 0)
+    const phrase =
+      lang === 'ru'
+        ? `Матч завершён. ${total} ${repWordRu(total)} ждут.`
+        : `Match complete. ${total} ${total === 1 ? 'rep' : 'reps'} await.`
+    speak(phrase, lang)
+  }
+
  function close(): void {
    // Если в Match Summary остались незакрытые челленджи — подтверждаем,
    // чтобы пользователь не «пролетел» окно по привычке и не потерял
@@ -125,6 +171,12 @@ export default function ReminderApp(): JSX.Element {
        if (!nativeConfirm(msg)) return
      }
    }
+    const next = queueRef.current.shift()
+    if (next) {
+      activateMode(next)
+      return
+    }
+    modeRef.current = { kind: 'idle' }
    setMode({ kind: 'idle' })
    window.api.reminderClose()
  }
@@ -145,6 +197,17 @@ export default function ReminderApp(): JSX.Element {
      />
    )
  }
+  if (mode.kind === 'meal') {
+    return (
+      <MealReminder
+        key={mode.meal.id + ':' + mode.meal.nextFireAt}
+        meal={mode.meal}
+        snoozeMinutes={settings?.snoozeMinutes ?? 5}
+        lang={lang}
+        onClose={close}
+      />
+    )
+  }
  return (
    <MatchSummaryView
      summary={mode.summary}
@@ -164,13 +227,16 @@ export default function ReminderApp(): JSX.Element {
        }
        // 2) Functional update: rapid-click race-safe.
        setMode((m) =>
-          m.kind === 'match'
-            ? {
+          {
+            if (m.kind !== 'match') return m
+            const nextMode: Mode = {
                kind: 'match',
                summary: m.summary,
                done: new Set([...m.done, id])
              }
-            : m
+            modeRef.current = nextMode
+            return nextMode
+          }
        )
      }}
      onClose={close}
@@ -350,6 +416,106 @@ function ExerciseReminder({
  )
 }

+function MealReminder({
+  meal,
+  snoozeMinutes,
+  lang,
+  onClose
+}: {
+  meal: Meal
+  snoozeMinutes: number
+  lang: Language
+  onClose: () => void
+}): JSX.Element {
+  const t = (key: string, vars?: Record<string, string | number>): string =>
+    translate(lang, key, vars)
+
+  async function done(): Promise<void> {
+    await window.api.markMealDone(meal.id)
+    onClose()
+  }
+  async function snooze(): Promise<void> {
+    // «Отложить» = напомнить снова через snoozeMinutes (перетираем
+    // запланированный планировщиком nextFireAt на завтра).
+    await window.api.updateMeal(meal.id, {
+      nextFireAt: Date.now() + snoozeMinutes * 60_000
+    })
+    onClose()
+  }
+
+  useEffect(() => {
+    function onKey(e: KeyboardEvent): void {
+      const targetTag = (e.target as HTMLElement | null)?.tagName
+      if (e.key === 'Enter') {
+        e.preventDefault()
+        void done()
+      } else if (e.key === 'Escape') {
+        e.preventDefault()
+        onClose()
+      } else if ((e.key === ' ' || e.code === 'Space') && targetTag !== 'BUTTON') {
+        e.preventDefault()
+        void snooze()
+      }
+    }
+    window.addEventListener('keydown', onKey)
+    return () => window.removeEventListener('keydown', onKey)
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [snoozeMinutes])
+
+  return (
+    <div className="reminder-shell flex flex-col h-full">
+      <div className="titlebar-drag h-8 px-2 flex items-center justify-end">
+        <button
+          onClick={onClose}
+          className="titlebar-nodrag w-7 h-6 grid place-items-center rounded-md hover:bg-destructive hover:text-white text-text/45 active:scale-90 transition-all"
+          aria-label={t('btn.close')}
+        >
+          <X size={13} strokeWidth={2.5} />
+        </button>
+      </div>
+
+      <div className="flex-1 flex flex-col items-center justify-center px-8 text-center">
+        <motion.div
+          initial={{ scale: 0.7, opacity: 0 }}
+          animate={{ scale: 1, opacity: 1 }}
+          transition={{ type: 'spring', stiffness: 300, damping: 24 }}
+          className="relative mb-6"
+        >
+          <div className="w-24 h-24 rounded-full bg-success text-white grid place-items-center shadow-[0_8px_30px_-8px_rgb(var(--success)/0.5)]">
+            <Icon name={meal.icon} size={44} strokeWidth={2} />
+          </div>
+        </motion.div>
+
+        <div className="text-[13px] uppercase tracking-[0.18em] text-success font-bold">
+          {t('meal.cta')}
+        </div>
+        <h1 className="font-serif text-[30px] leading-tight tracking-tight mt-2 mb-3 font-bold">
+          {meal.name}
+        </h1>
+        <div className="text-[13px] text-text/65 mt-1 inline-flex items-center gap-1.5 font-medium font-mono-num">
+          <Clock size={12} strokeWidth={2.4} /> {meal.time}
+        </div>
+      </div>
+
+      <div className="px-4 pb-4 space-y-2">
+        <button
+          onClick={done}
+          className="w-full h-12 rounded-2xl bg-success text-white text-[16px] font-bold inline-flex items-center justify-center gap-1.5 active:scale-[0.98] transition-transform"
+        >
+          <Check size={17} strokeWidth={2.5} /> {t('meal.btn.ate')}
+        </button>
+        <button
+          onClick={snooze}
+          className="w-full h-11 rounded-2xl bg-surface-2 text-text text-[15px] font-semibold inline-flex items-center justify-center gap-1.5 active:scale-[0.98] transition-transform"
+        >
+          <Clock size={15} strokeWidth={2.5} />{' '}
+          {t('btn.snooze_min', { n: snoozeMinutes })}
+        </button>
+      </div>
+    </div>
+  )
+}
+
 function MatchSummaryView({
  summary,
  done,
--- a/src/renderer/src/components/MealEditor.tsx
+++ b/src/renderer/src/components/MealEditor.tsx
@@ -0,0 +1,204 @@
+import { useEffect, useState } from 'react'
+import type { Meal } from '@shared/types'
+import { Modal } from './ui/Modal'
+import { Button } from './ui/Button'
+import { ICON_CHOICES, Icon } from '../lib/icon'
+import { useT } from '../i18n'
+
+export type MealDraft = {
+  name: string
+  time: string
+  icon: string
+  enabled: boolean
+  days: number[]
+}
+
+const EMPTY: MealDraft = {
+  name: '',
+  time: '13:00',
+  icon: 'UtensilsCrossed',
+  enabled: true,
+  days: []
+}
+
+// Понедельник-первый порядок для UI; значения — индексы getDay() (0=Вс).
+const WEEKDAY_ORDER = [1, 2, 3, 4, 5, 6, 0]
+
+type Props = {
+  open: boolean
+  meal?: Meal | null
+  onClose: () => void
+  onSave: (draft: MealDraft) => void
+}
+
+export function MealEditor({
+  open,
+  meal,
+  onClose,
+  onSave
+}: Props): JSX.Element {
+  const [draft, setDraft] = useState<MealDraft>(EMPTY)
+  const { t } = useT()
+
+  useEffect(() => {
+    if (meal) {
+      setDraft({
+        name: meal.name,
+        time: meal.time,
+        icon: meal.icon,
+        enabled: meal.enabled,
+        days: meal.days
+      })
+    } else {
+      setDraft(EMPTY)
+    }
+  }, [meal, open])
+
+  const canSave =
+    draft.name.trim().length > 0 && /^\d{1,2}:\d{2}$/.test(draft.time)
+  const weekdayLabels = t('meals.weekdays').split(',')
+
+  function toggleDay(dow: number): void {
+    setDraft((d) => ({
+      ...d,
+      days: d.days.includes(dow)
+        ? d.days.filter((x) => x !== dow)
+        : [...d.days, dow]
+    }))
+  }
+
+  return (
+    <Modal
+      open={open}
+      onClose={onClose}
+      title={meal ? t('editor.meal.title.edit') : t('editor.meal.title.new')}
+      footer={
+        <>
+          <Button variant="plain" onClick={onClose}>
+            {t('btn.cancel')}
+          </Button>
+          <Button disabled={!canSave} onClick={() => onSave(draft)}>
+            {t('btn.save')}
+          </Button>
+        </>
+      }
+    >
+      <div className="space-y-5">
+        <div className="rounded-2xl bg-surface-2 p-4 flex items-center gap-4">
+          <div className="w-14 h-14 rounded-2xl bg-accent text-white grid place-items-center shrink-0">
+            <Icon name={draft.icon} size={26} strokeWidth={2.2} />
+          </div>
+          <div className="min-w-0">
+            <div className="font-display text-[18px] font-semibold tracking-tight truncate">
+              {draft.name || t('editor.meal.preview.placeholder')}
+            </div>
+            <div className="text-[13px] text-text/55 mt-0.5 font-mono-num">
+              {draft.time}
+            </div>
+          </div>
+        </div>
+
+        <Field label={t('editor.field.name')}>
+          <input
+            value={draft.name}
+            onChange={(e) => setDraft({ ...draft, name: e.target.value })}
+            placeholder={t('editor.meal.name.placeholder')}
+            className="ios-input"
+            autoFocus
+          />
+        </Field>
+
+        <Field label={t('editor.meal.field.time')}>
+          <input
+            type="time"
+            value={draft.time}
+            onChange={(e) => setDraft({ ...draft, time: e.target.value })}
+            className="ios-input font-mono-num"
+          />
+        </Field>
+
+        <Field label={t('editor.meal.field.days')}>
+          <div className="grid grid-cols-7 gap-1.5">
+            {WEEKDAY_ORDER.map((dow) => {
+              const active = draft.days.includes(dow)
+              return (
+                <button
+                  key={dow}
+                  type="button"
+                  aria-pressed={active}
+                  onClick={() => toggleDay(dow)}
+                  className={[
+                    'h-10 rounded-xl text-[13px] font-semibold transition-all active:scale-95',
+                    active
+                      ? 'bg-accent text-white'
+                      : 'bg-surface-2 text-text/65 hover:text-text'
+                  ].join(' ')}
+                >
+                  {weekdayLabels[dow]}
+                </button>
+              )
+            })}
+          </div>
+          <div className="text-[12px] text-text/55 mt-1.5 leading-snug">
+            {t('editor.meal.field.days.hint')}
+          </div>
+        </Field>
+
+        <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) => (
+              <button
+                key={name}
+                type="button"
+                onClick={() => setDraft({ ...draft, icon: name })}
+                className={[
+                  'h-10 w-10 grid place-items-center rounded-xl transition-all active:scale-90',
+                  draft.icon === name
+                    ? 'bg-accent text-white'
+                    : 'bg-surface text-text/65 hover:text-text'
+                ].join(' ')}
+              >
+                <Icon name={name} size={17} strokeWidth={2.2} />
+              </button>
+            ))}
+          </div>
+        </Field>
+      </div>
+
+      <style>{`
+        .ios-input {
+          width: 100%;
+          height: 44px;
+          padding: 0 14px;
+          border-radius: 12px;
+          border: 0;
+          background: rgb(var(--surface-2));
+          color: rgb(var(--text));
+          font-size: 15px;
+          outline: none;
+          transition: box-shadow .15s ease;
+        }
+        .ios-input:focus {
+          box-shadow: 0 0 0 2px rgb(var(--accent) / 0.45);
+        }
+      `}</style>
+    </Modal>
+  )
+}
+
+function Field({
+  label,
+  children
+}: {
+  label: string
+  children: React.ReactNode
+}): JSX.Element {
+  return (
+    <label className="block">
+      <span className="block text-[12px] font-medium text-text/55 mb-1.5">
+        {label}
+      </span>
+      {children}
+    </label>
+  )
+}
--- a/src/renderer/src/components/Sidebar.tsx
+++ b/src/renderer/src/components/Sidebar.tsx
@@ -1,7 +1,15 @@
 import { useEffect, useRef } from 'react'
 import { NavLink } from 'react-router-dom'
 import { AnimatePresence, motion } from 'framer-motion'
-import { Sun, Dumbbell, Joystick, Flame, Settings2, X } from 'lucide-react'
+import {
+  Sun,
+  Dumbbell,
+  UtensilsCrossed,
+  Joystick,
+  Flame,
+  Settings2,
+  X
+} from 'lucide-react'
 import { useT } from '../i18n'

 type Item = {
@@ -20,6 +28,12 @@ const items: Item[] = [
    icon: Dumbbell,
    tint: 'bg-info'
  },
+  {
+    to: '/meals',
+    labelKey: 'nav.meals',
+    icon: UtensilsCrossed,
+    tint: 'bg-success'
+  },
  { to: '/games', labelKey: 'nav.games', icon: Joystick, tint: 'bg-accent-2' },
  {
    to: '/challenges',
--- a/src/renderer/src/i18n/dict.ts
+++ b/src/renderer/src/i18n/dict.ts
@@ -14,6 +14,7 @@ export const ru: Dict = {
  // Sidebar / nav
  'nav.today': 'Сегодня',
  'nav.exercises': 'Упражнения',
+  'nav.meals': 'Питание',
  'nav.games': 'Игры',
  'nav.challenges': 'Челленджи',
  'nav.settings': 'Настройки',
@@ -95,6 +96,34 @@ export const ru: Dict = {
  'exercises.row.meta': '{reps} раз · {interval}',
  'exercises.empty': 'Программа пуста — добавь первое упражнение',

+  // Meals (приёмы пищи)
+  'meals.kicker': 'Режим питания',
+  'meals.title': 'Питание',
+  'meals.presets': 'Быстрое добавление',
+  'meals.schedule': 'Расписание',
+  'meals.section.active': 'Активные · {n}',
+  'meals.section.disabled': 'Выключенные · {n}',
+  'meals.empty': 'Пока нет приёмов пищи — добавь первый или выбери пресет',
+  'meals.everyday': 'ежедневно',
+  'meals.weekdays': 'Вс,Пн,Вт,Ср,Чт,Пт,Сб',
+  'meals.preset.breakfast': 'Завтрак',
+  'meals.preset.lunch': 'Обед',
+  'meals.preset.dinner': 'Ужин',
+  'meals.preset.snack': 'Перекус',
+
+  // Meal editor
+  'editor.meal.title.new': 'Новый приём пищи',
+  'editor.meal.title.edit': 'Изменить приём пищи',
+  'editor.meal.preview.placeholder': 'Без названия',
+  'editor.meal.name.placeholder': 'Например, Обед',
+  'editor.meal.field.time': 'Время',
+  'editor.meal.field.days': 'Дни недели',
+  'editor.meal.field.days.hint': 'Ничего не выбрано — напоминаем каждый день',
+
+  // Meal reminder window
+  'meal.cta': 'Пора поесть',
+  'meal.btn.ate': 'Поел',
+
  // Exercise editor
  'editor.exercise.title.new': 'Новое упражнение',
  'editor.exercise.title.edit': 'Редактировать',
@@ -347,6 +376,7 @@ export const en: Dict = {
  // Sidebar / nav
  'nav.today': 'Today',
  'nav.exercises': 'Exercises',
+  'nav.meals': 'Meals',
  'nav.games': 'Games',
  'nav.challenges': 'Challenges',
  'nav.settings': 'Settings',
@@ -427,6 +457,34 @@ export const en: Dict = {
  'exercises.row.meta': '{reps} reps · {interval}',
  'exercises.empty': 'Program is empty — add your first exercise',

+  // Meals
+  'meals.kicker': 'Eating schedule',
+  'meals.title': 'Meals',
+  'meals.presets': 'Quick add',
+  'meals.schedule': 'Schedule',
+  'meals.section.active': 'Active · {n}',
+  'meals.section.disabled': 'Disabled · {n}',
+  'meals.empty': 'No meals yet — add one or pick a preset',
+  'meals.everyday': 'every day',
+  'meals.weekdays': 'Sun,Mon,Tue,Wed,Thu,Fri,Sat',
+  'meals.preset.breakfast': 'Breakfast',
+  'meals.preset.lunch': 'Lunch',
+  'meals.preset.dinner': 'Dinner',
+  'meals.preset.snack': 'Snack',
+
+  // Meal editor
+  'editor.meal.title.new': 'New meal',
+  'editor.meal.title.edit': 'Edit meal',
+  'editor.meal.preview.placeholder': 'Untitled',
+  'editor.meal.name.placeholder': 'e.g. Lunch',
+  'editor.meal.field.time': 'Time',
+  'editor.meal.field.days': 'Days of week',
+  'editor.meal.field.days.hint': 'None selected — reminds every day',
+
+  // Meal reminder window
+  'meal.cta': 'Time to eat',
+  'meal.btn.ate': 'Ate it',
+
  // Exercise editor
  'editor.exercise.title.new': 'New exercise',
  'editor.exercise.title.edit': 'Edit',
--- a/src/renderer/src/lib/icon-choices.test.ts
+++ b/src/renderer/src/lib/icon-choices.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest'
 import { ICON_CHOICES } from './icon-choices'
-import { SAMPLE_EXERCISES } from '@shared/types'
+import { MEAL_PRESETS, SAMPLE_EXERCISES, SAMPLE_MEALS } from '@shared/types'

 describe('ICON_CHOICES', () => {
  // Если иконка SAMPLE_EXERCISES не входит в whitelist, при первом запуске
@@ -16,6 +16,22 @@ describe('ICON_CHOICES', () => {
    }
  })

+  it('contains every icon used by SAMPLE_MEALS and MEAL_PRESETS', () => {
+    const allowed = new Set<string>(ICON_CHOICES)
+    for (const m of SAMPLE_MEALS) {
+      expect(
+        allowed.has(m.icon),
+        `icon "${m.icon}" for meal "${m.name}" is not in ICON_CHOICES`
+      ).toBe(true)
+    }
+    for (const p of MEAL_PRESETS) {
+      expect(
+        allowed.has(p.icon),
+        `icon "${p.icon}" for preset "${p.nameKey}" is not in ICON_CHOICES`
+      ).toBe(true)
+    }
+  })
+
  it('has no duplicates', () => {
    expect(new Set(ICON_CHOICES).size).toBe(ICON_CHOICES.length)
  })
--- a/src/renderer/src/lib/icon-choices.ts
+++ b/src/renderer/src/lib/icon-choices.ts
@@ -21,7 +21,9 @@ export const ICON_CHOICES = [
  'Apple',
  'GlassWater',
  'BookOpen',
-  'Sparkles'
+  'Sparkles',
+  'UtensilsCrossed',
+  'Soup'
 ] as const

 export type IconName = (typeof ICON_CHOICES)[number]
--- a/src/renderer/src/lib/icon.tsx
+++ b/src/renderer/src/lib/icon.tsx
@@ -19,7 +19,9 @@ import {
  Apple,
  GlassWater,
  BookOpen,
-  Sparkles
+  Sparkles,
+  UtensilsCrossed,
+  Soup
 } from 'lucide-react'
 import type { LucideProps } from 'lucide-react'
 import { ICON_CHOICES, type IconName } from './icon-choices'
@@ -44,7 +46,9 @@ const ICON_MAP: Record<IconName, React.ComponentType<LucideProps>> = {
  Apple,
  GlassWater,
  BookOpen,
-  Sparkles
+  Sparkles,
+  UtensilsCrossed,
+  Soup
 }

 /**
--- a/src/renderer/src/pages/Meals.tsx
+++ b/src/renderer/src/pages/Meals.tsx
@@ -0,0 +1,195 @@
+import { useState } from 'react'
+import { Plus, ChevronRight, UtensilsCrossed } from 'lucide-react'
+import { AnimatePresence, motion } from 'framer-motion'
+import { useAppStore } from '../store/appStore'
+import { MealEditor, type MealDraft } from '../components/MealEditor'
+import { Button } from '../components/ui/Button'
+import { Switch } from '../components/ui/Switch'
+import { Card, Row, SectionHeader } from '../components/ui/Card'
+import { Icon } from '../lib/icon'
+import { useT } from '../i18n'
+import { MEAL_PRESETS, type Meal } from '@shared/types'
+
+/** Сводка дней недели приёма пищи: «ежедневно» или короткие названия. */
+function daysLabel(days: number[], t: (k: string) => string): string {
+  if (days.length === 0) return t('meals.everyday')
+  const labels = t('meals.weekdays').split(',')
+  // Порядок Пн..Вс для читабельности.
+  const order = [1, 2, 3, 4, 5, 6, 0]
+  return order
+    .filter((d) => days.includes(d))
+    .map((d) => labels[d])
+    .join(', ')
+}
+
+export default function Meals(): JSX.Element {
+  const meals = useAppStore((s) => s.state?.meals ?? [])
+  const [editorOpen, setEditorOpen] = useState(false)
+  const [editing, setEditing] = useState<Meal | null>(null)
+  const { t } = useT()
+
+  // Единый список (включённые сверху). Важно: НЕ разбиваем на два <Card>, иначе
+  // при переключении строка переезжает между списками → её Switch
+  // размонтируется/монтируется заново, и анимация ползунка есть только при
+  // включении (mount с x:0→20), а при выключении нет. В одном keyed-списке
+  // компонент остаётся смонтированным → ползунок плавно ездит в обе стороны,
+  // а строка «переезжает» в свою группу через layout-анимацию.
+  const ordered = [...meals].sort((a, b) =>
+    a.enabled === b.enabled ? 0 : a.enabled ? -1 : 1
+  )
+
+  async function addPreset(
+    preset: (typeof MEAL_PRESETS)[number]
+  ): Promise<void> {
+    await window.api.addMeal({
+      name: t(preset.nameKey),
+      time: preset.time,
+      icon: preset.icon,
+      enabled: true,
+      days: []
+    })
+  }
+
+  return (
+    <div className="h-full overflow-y-auto">
+      <div className="max-w-3xl mx-auto px-4 sm:px-6 lg:px-10 pt-8 pb-12">
+        <div className="flex flex-col sm:flex-row sm:items-end sm:justify-between gap-4 mb-8">
+          <div>
+            <div className="text-[14px] text-text/65 font-semibold">
+              {t('meals.kicker')}
+            </div>
+            <h1 className="font-serif text-[34px] sm:text-[40px] leading-[1.02] tracking-tight mt-1 font-bold">
+              {t('meals.title')}
+            </h1>
+          </div>
+          <Button
+            onClick={() => {
+              setEditing(null)
+              setEditorOpen(true)
+            }}
+          >
+            <Plus size={15} strokeWidth={2.5} /> {t('btn.add')}
+          </Button>
+        </div>
+
+        {/* Пресеты быстрого добавления */}
+        <SectionHeader title={t('meals.presets')} />
+        <div className="flex flex-wrap gap-2 mb-7">
+          {MEAL_PRESETS.map((p) => (
+            <button
+              key={p.nameKey}
+              onClick={() => addPreset(p)}
+              className="inline-flex items-center gap-2 h-10 px-3.5 rounded-2xl bg-surface-2 hover:bg-accent/15 hover:text-accent text-text/80 text-[14px] font-semibold transition-colors active:scale-95"
+            >
+              <Icon name={p.icon} size={16} strokeWidth={2.3} />
+              {t(p.nameKey)}
+              <span className="font-mono-num text-text/45 text-[13px]">
+                {p.time}
+              </span>
+            </button>
+          ))}
+        </div>
+
+        {meals.length > 0 && (
+          <>
+            <SectionHeader title={t('meals.schedule')} />
+            <Card>
+              <AnimatePresence initial={false}>
+                {ordered.map((m, i) => (
+                  <motion.div
+                    key={m.id}
+                    layout
+                    initial={{ opacity: 0 }}
+                    animate={{ opacity: 1 }}
+                    exit={{ opacity: 0 }}
+                    transition={{ duration: 0.18, ease: 'easeOut' }}
+                  >
+                    <MealRow
+                      meal={m}
+                      last={i === ordered.length - 1}
+                      meta={`${m.time} · ${daysLabel(m.days, t)}`}
+                      onEdit={() => {
+                        setEditing(m)
+                        setEditorOpen(true)
+                      }}
+                    />
+                  </motion.div>
+                ))}
+              </AnimatePresence>
+            </Card>
+          </>
+        )}
+
+        {meals.length === 0 && (
+          <Card>
+            <div className="px-5 py-12 flex flex-col items-center text-center">
+              <div className="inline-flex w-14 h-14 rounded-2xl bg-accent text-white items-center justify-center mb-4">
+                <UtensilsCrossed size={24} strokeWidth={2.3} />
+              </div>
+              <div className="text-text/65 text-[15px] font-medium max-w-xs leading-snug">
+                {t('meals.empty')}
+              </div>
+            </div>
+          </Card>
+        )}
+
+        <MealEditor
+          open={editorOpen}
+          meal={editing}
+          onClose={() => setEditorOpen(false)}
+          onSave={async (draft: MealDraft) => {
+            if (editing) await window.api.updateMeal(editing.id, draft)
+            else await window.api.addMeal(draft)
+            setEditorOpen(false)
+          }}
+        />
+      </div>
+    </div>
+  )
+}
+
+function MealRow({
+  meal,
+  last,
+  meta,
+  onEdit
+}: {
+  meal: Meal
+  last: boolean
+  meta: string
+  onEdit: () => void
+}): JSX.Element {
+  return (
+    <Row last={last}>
+      <div
+        className={[
+          'w-9 h-9 rounded-lg grid place-items-center shrink-0 transition-colors duration-200',
+          meal.enabled ? 'bg-accent text-white' : 'bg-text/15 text-text/45'
+        ].join(' ')}
+      >
+        <Icon name={meal.icon} size={18} strokeWidth={2.2} />
+      </div>
+      <button
+        onClick={onEdit}
+        className="flex-1 min-w-0 text-left active:opacity-70 transition-opacity"
+      >
+        <div className="text-[16px] font-semibold truncate leading-tight">
+          {meal.name}
+        </div>
+        <div className="text-[14px] text-text/65 mt-1 font-medium font-mono-num">
+          {meta}
+        </div>
+      </button>
+      <Switch
+        checked={meal.enabled}
+        onChange={(v) => window.api.toggleMeal(meal.id, v)}
+      />
+      <button
+        onClick={onEdit}
+        className="text-text/30 hover:text-text/60 transition-colors"
+      >
+        <ChevronRight size={16} />
+      </button>
+    </Row>
+  )
+}
--- a/src/shared/ipc.ts
+++ b/src/shared/ipc.ts
@@ -8,6 +8,13 @@ export const IPC = {
  snooze: 'exercise:snooze',
  skip: 'exercise:skip',

+  // Meals (приёмы пищи — напоминания по времени суток)
+  addMeal: 'meal:add',
+  updateMeal: 'meal:update',
+  deleteMeal: 'meal:delete',
+  toggleMeal: 'meal:toggle',
+  markMealDone: 'meal:markDone',
+
  updateSettings: 'settings:update',
  getAccentColor: 'system:accentColor',
  getOsTheme: 'system:osTheme',
@@ -60,6 +67,7 @@ export const IPC = {
  // events from main → renderer
  evtTick: 'evt:tick',
  evtFire: 'evt:fire',
+  evtFireMeal: 'evt:fireMeal',
  evtMatchEnd: 'evt:matchEnd',
  evtStateChanged: 'evt:stateChanged',
  evtThemeChanged: 'evt:themeChanged',
@@ -69,7 +77,7 @@ export const IPC = {
  evtMaximizeChanged: 'evt:maximizeChanged',
  evtMeetingChanged: 'evt:meetingChanged',
  /**
-   * Шлётся когда история мутирует (markDone / snooze / skip /
+   * Шлётся когда история мутирует (markDone / markMealDone / snooze / skip /
   * markChallengeDone / clearHistory / import). Renderer'у достаточно
   * перезапросить getHistory. Раньше Dashboard переключал history по
   * `exercises` ref'у — но markDone мутирует Exercise in place, ref не
--- a/src/shared/meals.test.ts
+++ b/src/shared/meals.test.ts
@@ -0,0 +1,70 @@
+import { describe, it, expect } from 'vitest'
+import { nextMealOccurrence } from './types'
+
+/**
+ * Тесты планирования приёмов пищи по времени суток. Используем фиксированную
+ * «отправную точку» в локальном времени; helper тоже работает в локальном TZ,
+ * поэтому тесты детерминированы независимо от таймзоны CI.
+ *
+ * 2026-01-15 — четверг (getDay() === 4).
+ */
+const THU_10_00 = new Date(2026, 0, 15, 10, 0, 0, 0).getTime()
+const THU_14_00 = new Date(2026, 0, 15, 14, 0, 0, 0).getTime()
+const DAY_MS = 24 * 60 * 60 * 1000
+
+describe('nextMealOccurrence', () => {
+  it('возвращает сегодняшнее время, если оно ещё не наступило', () => {
+    const r = new Date(nextMealOccurrence('13:00', [], THU_10_00))
+    expect(r.getDate()).toBe(15)
+    expect(r.getHours()).toBe(13)
+    expect(r.getMinutes()).toBe(0)
+  })
+
+  it('переносит на завтра, если время сегодня уже прошло', () => {
+    const r = new Date(nextMealOccurrence('08:00', [], THU_10_00))
+    expect(r.getDate()).toBe(16)
+    expect(r.getHours()).toBe(8)
+  })
+
+  it('всегда строго в будущем относительно from', () => {
+    expect(nextMealOccurrence('13:00', [], THU_10_00)).toBeGreaterThan(
+      THU_10_00
+    )
+    expect(nextMealOccurrence('08:00', [], THU_10_00)).toBeGreaterThan(
+      THU_10_00
+    )
+  })
+
+  it('учитывает фильтр дней недели (только пятница)', () => {
+    // Четверг 10:00, напоминание 13:00, дни = [5] (пятница) → завтра 16-е.
+    const r = new Date(nextMealOccurrence('13:00', [5], THU_10_00))
+    expect(r.getDate()).toBe(16)
+    expect(r.getDay()).toBe(5)
+    expect(r.getHours()).toBe(13)
+  })
+
+  it('сегодня входит в фильтр и время не прошло → сегодня', () => {
+    const r = new Date(nextMealOccurrence('13:00', [4], THU_10_00))
+    expect(r.getDate()).toBe(15)
+    expect(r.getDay()).toBe(4)
+  })
+
+  it('единственный день недели, время прошло → следующая неделя', () => {
+    // Четверг 14:00, 13:00 уже прошло, дни = [4] → следующий четверг 22-е.
+    const r = new Date(nextMealOccurrence('13:00', [4], THU_14_00))
+    expect(r.getDate()).toBe(22)
+    expect(r.getDay()).toBe(4)
+  })
+
+  it('пустой массив дней = каждый день', () => {
+    const r = new Date(nextMealOccurrence('23:59', [], THU_10_00))
+    expect(r.getDate()).toBe(15)
+  })
+
+  it('малформированное время → +24ч (safety)', () => {
+    expect(nextMealOccurrence('99:99', [], THU_10_00)).toBe(THU_10_00 + DAY_MS)
+    expect(nextMealOccurrence('not-a-time', [], THU_10_00)).toBe(
+      THU_10_00 + DAY_MS
+    )
+  })
+})
--- a/src/shared/types.ts
+++ b/src/shared/types.ts
@@ -42,6 +42,40 @@ export type Exercise = {
  adaptive?: boolean
 }

+/**
+ * Приём пищи — напоминание ПО ВРЕМЕНИ СУТОК (в отличие от Exercise, который
+ * по интервалу). Срабатывает, когда настенные часы достигают `time` в активный
+ * день недели; после этого `nextFireAt` пересчитывается на следующее вхождение.
+ */
+export type Meal = {
+  id: string
+  name: string
+  /** "HH:MM" 24ч — время напоминания. */
+  time: string
+  icon: string
+  enabled: boolean
+  /** Дни недели 0=Вс..6=Сб, когда напоминать. Пусто = каждый день. */
+  days: number[]
+  /** Вычисляемое: epoch ms следующего срабатывания. */
+  nextFireAt: number
+  lastDoneAt?: number
+}
+
+/** Пресет быстрого добавления приёма пищи. Имя резолвится через i18n. */
+export type MealPreset = {
+  /** i18n-ключ локализованного имени, напр. 'meals.preset.breakfast'. */
+  nameKey: string
+  time: string
+  icon: string
+}
+
+export const MEAL_PRESETS: MealPreset[] = [
+  { nameKey: 'meals.preset.breakfast', time: '08:00', icon: 'Coffee' },
+  { nameKey: 'meals.preset.lunch', time: '13:00', icon: 'UtensilsCrossed' },
+  { nameKey: 'meals.preset.dinner', time: '19:00', icon: 'Soup' },
+  { nameKey: 'meals.preset.snack', time: '16:00', icon: 'Apple' }
+]
+
 export type NotificationMode = 'toast' | 'modal' | 'both'
 export type Theme = 'light' | 'dark' | 'system'
 export type Language = 'ru' | 'en'
@@ -99,6 +133,7 @@ export type Settings = {
 */
 export type AppState = {
  exercises: Exercise[]
+  meals: Meal[]
  settings: Settings
  challenges: Challenge[]
  gamesEnabled: Partial<Record<GameId, boolean>>
@@ -112,10 +147,11 @@ export type PersistedState = AppState & {
 export type HistoryAction = 'done' | 'skip' | 'snooze'

 /**
- * Источник записи: обычное напоминание (от scheduler'а) или матч (челлендж).
+ * Источник записи: обычное напоминание (от scheduler'а), приём пищи или
+ * матч (челлендж).
 * Используется для UI («подтянулся в матче» vs «по таймеру») и аналитики.
 */
-export type HistorySource = 'reminder' | 'match'
+export type HistorySource = 'reminder' | 'meal' | 'match'

 export type HistoryEntry = {
  /** ms epoch */
@@ -314,6 +350,37 @@ export function isQuietAt(qh: QuietHours, now: Date): boolean {
  return false
 }

+/**
+ * Следующее срабатывание приёма пищи СТРОГО после `fromMs`: ближайший день
+ * (включая сегодня, если время ещё не прошло), чей weekday входит в `days`
+ * (пустой массив = каждый день). Считает через календарную арифметику
+ * (`setDate`/`setHours`), а не ms — корректно переживает переход на летнее/
+ * зимнее время (см. урок history.ts). Малформ `time` → `fromMs + 24ч`.
+ */
+export function nextMealOccurrence(
+  time: string,
+  days: number[],
+  fromMs: number
+): number {
+  const hm = parseHHMM(time)
+  const dayMs = 24 * 60 * 60 * 1000
+  if (hm === null) return fromMs + dayMs
+  const h = Math.floor(hm / 60)
+  const min = hm % 60
+  const base = new Date(fromMs)
+  // 0..7: ищем ближайший активный день. 7 — запас на случай, когда выбран
+  // единственный день недели, и сегодняшнее время уже прошло.
+  for (let i = 0; i <= 7; i++) {
+    const cand = new Date(base)
+    cand.setDate(cand.getDate() + i)
+    cand.setHours(h, min, 0, 0)
+    if (cand.getTime() <= fromMs) continue
+    const dow = cand.getDay()
+    if (days.length === 0 || days.includes(dow)) return cand.getTime()
+  }
+  return fromMs + dayMs
+}
+
 export const SAMPLE_EXERCISES: Omit<Exercise, 'id' | 'nextFireAt'>[] = [
  {
    name: 'Приседания',
@@ -357,6 +424,22 @@ export const SAMPLE_EXERCISES: Omit<Exercise, 'id' | 'nextFireAt'>[] = [
  }
 ]

+/**
+ * Стартовые приёмы пищи — выключены по умолчанию (как hydration/eyes/posture).
+ * Пользователь включает нужные на вкладке «Питание» или добавляет свои.
+ */
+export const SAMPLE_MEALS: Omit<Meal, 'id' | 'nextFireAt'>[] = [
+  { name: 'Завтрак', time: '08:00', icon: 'Coffee', enabled: false, days: [] },
+  {
+    name: 'Обед',
+    time: '13:00',
+    icon: 'UtensilsCrossed',
+    enabled: false,
+    days: []
+  },
+  { name: 'Ужин', time: '19:00', icon: 'Soup', enabled: false, days: [] }
+]
+
 export type UpdaterStatus =
  | { kind: 'idle'; lastCheckedAt?: number }
  | { kind: 'unsupported'; reason: string }
--- a/tailwind.config.mjs
+++ b/tailwind.config.mjs
Author	SHA1	Message	Date
Codex	b5f6952ad2	chore(release): v0.6.1	2026-06-06 12:37:53 +07:00
Codex	ffe80b62c4	fix: harden reminders and state handling	2026-06-06 02:27:04 +07:00
AnRil	ad000c722e	fix(meals): плавная анимация переключателя в обе стороны Список «Питания» разбивался на два <Card> (активные/выключенные). При переключении строка переезжала между списками → её Switch размонтировался и монтировался заново, и ползунок анимировался только при включении (mount x:0→20), а при выключении — нет. Теперь единый keyed-список (включённые сверху): Switch остаётся смонтированным, ползунок плавно ездит в обе стороны, а строка «переезжает» в свою группу через framer layout-анимацию. Иконке добавлен transition-colors. Глобальный Switch не трогал — Упражнения/Дашборд не затронуты. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>	2026-06-06 00:13:07 +07:00
AnRil	c0827f887f	chore(release): v0.6.0	2026-06-05 22:16:52 +07:00
AnRil	bef733a877	feat(meals): вкладка «Питание» — напоминания о еде по времени суток Новая модель Meal — напоминание по настенным часам (time HH:MM + дни недели), в отличие от interval-based Exercise. Отдельная вкладка «Питание» с пресетами быстрого добавления (Завтрак/Обед/Ужин/Перекус). - shared: тип Meal, meals в AppState, nextMealOccurrence (DST-safe), SAMPLE_MEALS, MEAL_PRESETS; IPC-каналы meal:* + evtFireMeal - main: валидация (строгая HH:MM-проверка диапазона), store-мутаторы с пересчётом nextFireAt, scheduler.checkDueMeals (гейт только globalEnabled, grace-окно 120с, игнор тихих часов/ВКС), notifications.fireMealReminder, IPC-хендлеры - renderer: вкладка Meals + MealEditor (время/дни/иконка), MealReminder в окне напоминания (Поел/Отложить, TTS), пункт в Sidebar, маршрут, i18n RU/EN, иконки UtensilsCrossed/Soup - persistence: meals additive (без bump схемы — старые state'ы получают []) - +24 теста (203 -> 227): nextMealOccurrence, валидаторы приёмов пищи, scheduler meal-gating (вкл/выкл, grace, игнор тихих часов) Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>	2026-06-03 23:45:34 +07:00