chore: bump version to 1.9.0

- --commit: после генерации отчёта сохраняет период в
  period.last_used.from/to YAML-конфига
- При period.dynamic=true следующий запуск вычисляет период от last_used:
  полный месяц → следующий месяц, произвольный диапазон → та же длина
- При period.dynamic=false перезаписывает default_from/default_to
- При period.precision=datetime сохраняет timestamps с точностью до секунд
- --commit без --output сохраняет отчёт по шаблону из конфига
- compute_next_period() в config.py
- save_period_to_config() в yaml_config.py
- 23 новых теста (7 CLI, 6 config, 6 yaml, 4 date_range)

Closes #44

README.md

@@ -12,10 +12,14 @@ CLI-инструмент для генерации отчётов по зада
 - Авторизация через Redmine API token или логин/пароль.
 - Группировка задач по проекту и версии.
 - Перевод статусов задач на русский язык.
+- Разбивка по типам активности (`--by-activity`).
 - Вывод в консоль (таблица / компактный вид).
 - Экспорт в ODT, CSV, Markdown, HTML, JSON и Excel (.xlsx).
 - Excel-отчёт с merge-ячейками по проекту/версии, итогами, автошириной, автофильтром и закреплённой шапкой.
 - Сводка по времени (`--summary`).
+- YAML-конфиг (`~/.config/redmine-reporter/config.yml`): шаблон имени файла, путь по умолчанию, период, SMTP.
+- Умное разрешение `--output`: bare-формат (`xlsx`) → путь по шаблону, без расширения → автодописывание.
+- `--commit`: автосохранение отчёта в файл + фиксация периода в YAML-конфиге для следующего запуска.
 - Понятные сообщения об ошибках Redmine API (401/403/5xx, таймаут, сеть).
 - Загрузка альтернативного `.env` через `--config`.
 
@@ -38,28 +42,70 @@ pip install -e ".[dev]"
 
 ## Настройка
 
-Создайте файл `.env` в корне проекта. Он не должен попадать в git.
+Источники конфигурации (от высшего приоритета к низшему):
 
-Рекомендуемый вариант авторизации:
+```
+CLI-флаги  >  переменные окружения  >  .env  >  YAML-конфиг  >  кодовые дефолты
+```
+
+### YAML-конфиг (основной способ)
+
+```bash
+# Сгенерировать YAML из текущего .env
+redmine-reporter --init-config
+
+# Редактировать под себя
+vim ~/.config/redmine-reporter/config.yml
+```
+
+Структура:
+
+```yaml
+redmine:
+  url: https://red.eltex.loc
+  api_key: ${REDMINE_API_KEY}
+  author: "Кокос А.А."
+  verify_ssl: true
+
+period:
+  precision: date                   # date | datetime
+  default_from: "2026-06-01"
+  default_to: "2026-06-30"
+  dynamic: false
+  # last_used заполняется --commit (см. docs/CONFIG.md)
+
+output:
+  dir: ~/reports
+  filename: "{author}_{from}_{to}.{ext}"
+  default_format: xlsx
+
+email:
+  smtp:
+    host: smtp.example.com
+    port: 587
+    user: bot@example.com
+    password: ${SMTP_PASSWORD}
+    tls: true
+  from: bot@example.com
+  to:
+    - boss@example.com
+  subject: "Отчёт {author} за {period}"
+```
+
+Шаблон `output.filename` поддерживает `{author}`, `{from}`, `{to}`, `{date}` (DD_MM_YYYY), `{ext}`.
+
+Подробнее: [docs/CONFIG.md](docs/CONFIG.md).
+
+### `.env` (legacy)
 
 ```ini
 REDMINE_URL=https://red.eltex.loc/
 REDMINE_API_KEY=ваш_api_token
 REDMINE_AUTHOR=Иванов Иван Иванович
-
 DEFAULT_FROM_DATE=2026-01-01
 DEFAULT_TO_DATE=2026-01-31
 ```
 
-Резервный вариант:
-
-```ini
-REDMINE_URL=https://red.eltex.loc/
-REDMINE_USER=ваш.логин
-REDMINE_PASSWORD=ваш_пароль
-REDMINE_AUTHOR=Иванов Иван Иванович
-```
-
 Переменные окружения:
 
 | Переменная | Обязательность | Описание |
@@ -68,7 +114,7 @@ REDMINE_AUTHOR=Иванов Иван Иванович
 | `REDMINE_API_KEY` | Да, если нет логина и пароля | Redmine API token. |
 | `REDMINE_USER` | Да, если нет токена | Логин Redmine. |
 | `REDMINE_PASSWORD` | Да, если нет токена | Пароль Redmine. |
-| `REDMINE_AUTHOR` | Нет | Имя автора для ODT-отчёта. |
+| `REDMINE_AUTHOR` | Нет | Имя автора для отчёта. |
 | `DEFAULT_FROM_DATE` | Нет | Начальная дата периода по умолчанию (`YYYY-MM-DD`). |
 | `DEFAULT_TO_DATE` | Нет | Конечная дата периода по умолчанию (`YYYY-MM-DD`). |
 | `REDMINE_VERIFY` | Нет | TLS-проверка: `true` / `false` / путь к CA bundle. |
@@ -85,13 +131,13 @@ source .venv/bin/activate
 redmine-reporter
 ```
 
-Отчёт за произвольный период:
+Произвольный период:
 
 ```bash
 redmine-reporter --date 2026-02-01--2026-02-28
 ```
 
-Отчёт по другому пользователю:
+Другой пользователь:
 
 ```bash
 redmine-reporter --user-id 42
@@ -99,56 +145,76 @@ redmine-reporter --user-login ivanov
 redmine-reporter --user-name "Иванов И.И."
 ```
 
-`--user-name` требует точного совпадения; если найдено несколько пользователей, CLI сообщает об ошибке и просит использовать `--user-id`.
+Переопределить URL / API-ключ:
-
-Переопределить URL/API-ключ из `.env`:
 
 ```bash
 redmine-reporter --url https://red.example.com --api-key ваш_токен
 ```
 
-Альтернативный конфигурационный файл:
+Альтернативный `.env`:
 
 ```bash
 redmine-reporter --config /path/to/.env
 ```
 
-Компактный вывод:
+Компактный / отладочный вывод:
 
 ```bash
 redmine-reporter --compact
-```
-
-Отладочный вывод:
-
-```bash
 redmine-reporter --debug
 ```
 
-Экспорт:
+Экспорт с явным путём:
 
 ```bash
-redmine-reporter --output report.odt
-redmine-reporter --output report.csv
-redmine-reporter --output report.md
-redmine-reporter --output report.html
-redmine-reporter --output report.json
 redmine-reporter --output report.xlsx
+redmine-reporter --output /path/to/report.odt
 ```
 
-Отчёт без затраченного времени (работает для всех форматов):
+Экспорт — только формат (путь и имя берутся из YAML-шаблона):
+
+```bash
+redmine-reporter --output xlsx          # → output.dir/отчёт_01_07_2026.xlsx
+redmine-reporter --output odt           # → output.dir/отчёт_01_07_2026.odt
+```
+
+Экспорт — путь без расширения (дописывается `default_format` из конфига):
+
+```bash
+redmine-reporter --output /tmp/report   # → /tmp/report.xlsx (если default_format: xlsx)
+```
+
+Без времени / с разбивкой по активностям:
 
 ```bash
 redmine-reporter --no-time
-redmine-reporter --no-time --output report.xlsx
+redmine-reporter --by-activity
+redmine-reporter --by-activity --summary
 ```
 
-Сводка по времени:
+Сводка:
 
 ```bash
 redmine-reporter --summary
 ```
 
+Фиксация периода (`--commit`):
+
+```bash
+# Сгенерировать, сохранить в файл по шаблону, запомнить период
+redmine-reporter --commit
+
+# С явным путём
+redmine-reporter --commit --output report.xlsx
+
+# Следующий запуск (без --date) возьмёт следующий период автоматически
+redmine-reporter
+
+# При precision=datetime запоминает момент времени
+# (предотвращает дублирование записей внутри дня)
+redmine-reporter --commit
+```
+
 ## Форматы вывода
 
 | Формат | Особенности |
@@ -175,5 +241,7 @@ mypy redmine_reporter
 ## Безопасность
 
 - Не коммитьте `.env`, API token, пароль или логин.
+- YAML-конфиг имеет права `0600`, директория — `0700`.
+- Рекомендуется хранить секреты через `${VAR}`, а не plaintext.
 - Используйте аккаунт с минимальными правами, достаточными для чтения time entries и задач.
 - Инструмент работает только в режиме чтения и не изменяет данные в Redmine.

docs/CONFIG.md

@@ -0,0 +1,259 @@
+# Настройка redmine-reporter
+
+## Источники конфигурации
+
+Приоритет, от высшего к низшему:
+
+```
+CLI-флаги  >  переменные окружения  >  .env  >  YAML  >  кодовые дефолты
+```
+
+Если значение не задано на верхнем уровне, берётся уровень ниже. `.env` и YAML
+работают одновременно — можно оставить оба, можно удалить `.env` после миграции.
+
+## YAML-конфиг
+
+Основной файл: `~/.config/redmine-reporter/config.yml`.
+
+Создаётся с правами `0600` (владелец: чтение/запись, остальные: доступ запрещён).
+Директория `~/.config/redmine-reporter/` — с правами `0700`.
+
+Если права файла шире `0600`, при запуске выводится предупреждение.
+
+### Структура
+
+```yaml
+redmine:
+  url: https://red.eltex.loc
+  api_key: ${REDMINE_API_KEY}
+  author: "Кокос А.А."
+  verify_ssl: true
+
+period:
+  precision: date
+  default_from: "2026-06-01"
+  default_to: "2026-06-30"
+  dynamic: false
+  last_used:
+    from: "2026-06-30T09:00:00"
+    to: "2026-06-30T12:00:00"
+
+output:
+  dir: ~/reports
+  filename: "{author}_{from}_{to}.{ext}"
+  default_format: xlsx
+
+email:
+  smtp:
+    host: smtp.example.com
+    port: 587
+    user: bot@example.com
+    password: ${SMTP_PASSWORD}
+    tls: true
+  from: bot@example.com
+  to:
+    - boss@example.com
+  cc: []
+  bcc: []
+  subject: "Отчёт {author} за {period}"
+  body_text: "Во вложении отчёт."
+  attach: true
+```
+
+### `period.precision` — точность периода
+
+Определяет, как вычисляется следующий период после фиксации:
+
+- `date` (по умолчанию) — период с точностью до дня. Следующий запуск (после `--commit`) начинается со следующего дня.
+- `datetime` — период с точностью до секунды. При повторном запуске time entries с `created_on` и `updated_on` ранее `last_used.to` исключаются (AND-логика: запись исключается только если **оба** поля раньше cutoff). Это предотвращает дублирование при отправке отчёта внутри рабочего дня.
+
+`last_used.from` / `last_used.to` записываются автоматически при `--commit`. Вручную редактировать не требуется.
+
+### `--commit` — автофиксация периода
+
+Флаг `--commit` сохраняет использованный период в YAML-конфиг, чтобы следующий запуск автоматически начинался с нового периода.
+
+**Что делает:**
+
+1. Генерирует отчёт как обычно.
+2. Сохраняет отчёт в файл:
+   - Если указан `--output` — по явному пути.
+   - Если `--output` не указан — по шаблону из `output.dir` / `output.filename`.
+3. Записывает `period.last_used.from` / `period.last_used.to` в YAML-конфиг.
+4. При `period.precision: datetime` сохраняет текущий момент времени (ISO с секундами).
+5. При `period.precision: date` сохраняет даты периода.
+
+**Поведение `period.dynamic`:**
+
+- `dynamic: true` — следующий запуск (без `--date`) вычисляет период от `last_used`:
+  - Полный календарный месяц → следующий полный месяц.
+  - Произвольный диапазон → та же длительность, начиная со дня после `last_used.to`.
+- `dynamic: false` — `--commit` перезаписывает `default_from`/`default_to` на использованный период.
+
+**Примеры:**
+
+```bash
+# Июнь 2026 → следующий запуск (без --date) → июль 2026
+redmine-reporter --date 2026-06-01--2026-06-30 --commit
+
+# Произвольный диапазон: 15-20 июня → следующий запуск → 21-26 июня
+redmine-reporter --date 2026-06-15--2026-06-20 --commit
+
+# С datetime-точностью: повторный запуск не дублирует записи
+redmine-reporter --commit
+```
+
+### `output` — путь и имя файла по умолчанию
+
+Секция управляет тем, куда и с каким именем сохраняется отчёт, когда `--output` не содержит полного пути.
+
+**Правила разрешения `--output`:**
+
+| Аргумент `--output` | Поведение |
+|---|---|
+| `/полный/путь/report.xlsx` | Используется как есть, конфиг игнорируется |
+| `xlsx` (bare format: `xlsx`, `odt`, `csv`, `md`, `html`, `json`) | Путь = `output.dir` + `output.filename`, расширение = bare format |
+| `/tmp/report` (путь без расширения) | Дописывается `.default_format` → `/tmp/report.xlsx` |
+
+**Шаблон имени файла:**
+
+`output.filename` поддерживает подстановки:
+
+| Плейсхолдер | Описание | Пример |
+|---|---|---|
+| `{author}` | Имя автора (пробелы → `_`) | `Кокос_А.А.` |
+| `{from}` | Начало периода, `YYYY-MM-DD` | `2026-06-01` |
+| `{to}` | Конец периода, `YYYY-MM-DD` | `2026-06-30` |
+| `{date}` | Конец периода, `DD_MM_YYYY` | `30_06_2026` |
+| `{ext}` | Расширение файла без точки | `xlsx` |
+
+Неизвестные плейсхолдеры остаются в имени как есть.
+
+Примеры:
+
+```yaml
+# По умолчанию
+filename: "{author}_{from}_{to}.{ext}"    # → Кокос_А.А._2026-06-01_2026-06-30.xlsx
+
+# Русский формат даты
+filename: "отчёт_{date}.{ext}"            # → отчёт_30_06_2026.xlsx
+
+# Без автора, только диапазон
+filename: "report_{from}--{to}.{ext}"     # → report_2026-06-01--2026-06-30.xlsx
+```
+
+### Подстановка переменных окружения
+
+В любом строковом значении YAML можно использовать `${VAR}` — при загрузке
+оно заменяется на значение переменной окружения:
+
+```yaml
+redmine:
+  api_key: ${REDMINE_API_KEY}
+
+email:
+  smtp:
+    password: ${SMTP_PASSWORD}
+```
+
+Это безопаснее, чем хранить секреты plaintext в YAML. Однако plaintext-секреты
+**не запрещены** — если вписать `api_key: "abc123"` напрямую, система примет.
+Права `0600` — основная защита.
+
+## Разрешение выходного пути
+
+Функция `resolve_output_path()` определяет итоговый путь к файлу:
+
+1. `--output` не указан → консольный вывод.
+2. `--output xlsx` (bare format) → путь формируется как `output.dir / output.filename` с подстановкой `{ext}` = bare format и дат из периода.
+3. `--output /path/report` (без расширения) → дописывается `.output.default_format`.
+4. `--output /path/report.csv` (с расширением) → используется как есть.
+5. `--output /path/report.xyz` (неизвестное расширение) → используется как есть, форматтер выбирается по расширению.
+
+## Миграция с `.env` на YAML
+
+### Быстрый старт
+
+```bash
+# 1. Генерируем YAML из текущего .env
+redmine-reporter --init-config
+
+# 2. Проверяем, что создалось
+cat ~/.config/redmine-reporter/config.yml
+
+# 3. Редактируем под себя (шаблон имени, период, etc.)
+vim ~/.config/redmine-reporter/config.yml
+```
+
+### Что делает `--init-config`
+
+- Читает текущие значения из `.env` и переменных окружения.
+- Формирует YAML со всеми секциями (`redmine`, `period`, `output`, `email`).
+- Секреты (`REDMINE_API_KEY`, `SMTP_PASSWORD`) записывает как `${VAR}`, если
+  переменная существует, иначе — пустая строка.
+- Создаёт файл с правами `0600`, директорию — с `0700`.
+
+### Флаги миграции
+
+| Флаг | Назначение |
+|---|---|
+| `--init-config` | Создать YAML и выйти |
+| `--init-config --force` | Перезаписать существующий YAML |
+| `--config-path PATH` | Сохранить YAML по указанному пути (по умолчанию `~/.config/redmine-reporter/config.yml`) |
+
+### Проверка после миграции
+
+```bash
+# Запустить без .env в текущей директории
+cd /tmp
+redmine-reporter --date 2026-06-01--2026-06-30
+```
+
+Если отработал — YAML-конфиг читается корректно. Если `REDMINE_URL is required` —
+проверь права:
+
+```bash
+ls -la ~/.config/redmine-reporter/
+# config.yml должно быть -rw------- (600)
+# директория должна быть drwx------ (700)
+```
+
+### Сосуществование `.env` и YAML
+
+Можно оставить оба источника. `.env` имеет **более высокий приоритет**, чем YAML:
+
+```
+.env значения переопределяют YAML, если заданы
+YAML работает как базовый слой для всего, что не в .env
+```
+
+Это safe — если с YAML что-то пойдёт не так, просто положи `.env` обратно.
+
+### Откат
+
+```bash
+rm ~/.config/redmine-reporter/config.yml
+```
+
+## `.env` (legacy)
+
+Для обратной совместимости `.env` продолжает работать без изменений.
+
+```ini
+REDMINE_URL=https://red.eltex.loc
+REDMINE_API_KEY=your-api-key
+REDMINE_AUTHOR=Кокос А.А.
+DEFAULT_FROM_DATE=2026-06-01
+DEFAULT_TO_DATE=2026-06-30
+```
+
+Если ни `.env`, ни YAML не заданы — используются кодовые дефолты (текущий месяц
+как период, стандартный путь сертификатов, пустой автор).
+
+## Безопасность
+
+- YAML-конфиг: права `0600`, директория `0700`.
+- Права шире `0600` → warning в stderr при каждом запуске.
+- Секреты рекомендуется хранить через `${VAR}`, а не plaintext.
+- `.env` **не рекомендуется** для постоянных настроек — оставьте его только
+  для CI/CD или временных переопределений.

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "redmine-reporter"
-version = "1.7.0"
+version = "1.9.0"
 description = "Redmine time-entry based issue reporter for internal use"
 readme = "README.md"
 authors = [{ name = "Artem Kokos", email = "artem-kokos@mail.ru" }]
@@ -24,6 +24,7 @@ dependencies = [
     "python-dotenv>=1.0.0",
     "odfpy>=1.4.0",
     "openpyxl>=3.1.0",
+    "pyyaml>=6.0",
 ]
 
 [project.optional-dependencies]
@@ -57,5 +58,5 @@ multi_line_output = 3
 warn_unused_configs = true
 
 [[tool.mypy.overrides]]
-module = ["odf.*", "redminelib.*", "tabulate", "openpyxl.*"]
+module = ["odf.*", "redminelib.*", "tabulate", "openpyxl.*", "yaml", "requests", "urllib3.*"]
 ignore_missing_imports = true

redmine_reporter/__init__.py

@@ -1 +1 @@
-__version__ = "1.7.0"
+__version__ = "1.9.0"

redmine_reporter/cli.py

@@ -3,14 +3,18 @@ import logging
 import os
 import re
 import sys
-from datetime import datetime
+from datetime import datetime, timezone
+from pathlib import Path
 from typing import List, Optional
 
+import yaml
+
 from . import __version__
 from .client import RedmineAPIError, fetch_issues_with_spent_time
 from .config import Config
 from .formatters.factory import get_console_formatter, get_formatter_by_extension
 from .report_builder import build_grouped_report, calculate_summary
+from .yaml_config import ensure_config_dir, resolve_output_path, save_period_to_config
 
 
 def parse_date_range(date_arg: str) -> tuple[str, str]:
@@ -35,6 +39,89 @@ def parse_date_range(date_arg: str) -> tuple[str, str]:
     return start.isoformat(), end.isoformat()
 
 
+def _run_init_config(config_path: str, force: bool) -> int:
+    """Создаёт YAML-конфиг из текущих настроек окружения."""
+    path = Path(config_path)
+
+    if path.exists() and not force:
+        print(
+            f"⚠️  {path} already exists.\n" f"   Use --init-config --force to overwrite.",
+            file=sys.stderr,
+        )
+        return 1
+
+    # Собираем значения из окружения
+    data = {
+        "redmine": {
+            "url": os.getenv("REDMINE_URL", "").strip().rstrip("/"),
+            "api_key": ("${REDMINE_API_KEY}" if os.getenv("REDMINE_API_KEY") else ""),
+            "author": os.getenv("REDMINE_AUTHOR", "").strip(),
+            "verify_ssl": True,
+        },
+        "period": {
+            "precision": "date",
+            "default_from": os.getenv("DEFAULT_FROM_DATE", "").strip(),
+            "default_to": os.getenv("DEFAULT_TO_DATE", "").strip(),
+            "dynamic": False,
+        },
+        "output": {
+            "dir": "",
+            "filename": "{author}_{from}_{to}.{ext}",
+            "default_format": "xlsx",
+        },
+        "email": {
+            "smtp": {
+                "host": "",
+                "port": 587,
+                "user": "",
+                "password": ("${SMTP_PASSWORD}" if os.getenv("SMTP_PASSWORD") else ""),
+                "tls": True,
+            },
+            "from": "",
+            "to": [],
+            "cc": [],
+            "bcc": [],
+            "subject": "Отчёт {author} за {period}",
+            "body_text": "Во вложении отчёт.",
+            "attach": True,
+        },
+    }
+
+    ensure_config_dir(path.parent)
+    with open(path, "w", encoding="utf-8") as fh:
+        yaml.dump(data, fh, allow_unicode=True, default_flow_style=False, sort_keys=False)
+    path.chmod(0o600)
+
+    sections_found = [s for s in data if data[s]]
+    print(f"✅ Config written to {path}")
+    print(f"   Sections: {', '.join(sections_found)}")
+    print("   Secrets stored as ${VAR} references where detected.")
+    return 0
+
+
+def _compute_dedup_cutoff() -> Optional[datetime]:
+    """Compute deduplication cutoff from config.
+
+    If period.precision == 'datetime' and period.last_used.to is set,
+    return the datetime to filter out entries already accounted for.
+    Otherwise return None.
+    """
+    if Config.get_period_precision() != "datetime":
+        return None
+
+    last_to = Config.get_last_used_to()
+    if not last_to:
+        return None
+
+    try:
+        dt = datetime.fromisoformat(last_to.replace("Z", "+00:00"))
+        if dt.tzinfo is None:
+            dt = dt.replace(tzinfo=timezone.utc)
+        return dt
+    except (ValueError, TypeError):
+        return None
+
+
 def main(argv: Optional[List[str]] = None) -> int:
     parser = argparse.ArgumentParser(
         prog="redmine-reporter",
@@ -42,7 +129,7 @@ def main(argv: Optional[List[str]] = None) -> int:
     )
     parser.add_argument(
         "--date",
-        default=Config.get_default_date_range(),
+        default=None,
         help="Date range in format YYYY-MM-DD--YYYY-MM-DD (default: current month or from .env)",
     )
     parser.add_argument(
@@ -88,8 +175,55 @@ def main(argv: Optional[List[str]] = None) -> int:
         "--user-name",
         help="Redmine user full name for the report (alternative to --user-id; ambiguous names are rejected)",
     )
+    parser.add_argument(
+        "--by-activity",
+        action="store_true",
+        help="Break down spent time by activity type",
+    )
+    parser.add_argument(
+        "--init-config",
+        action="store_true",
+        help="Generate YAML config from current environment and exit",
+    )
+    parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Allow overwriting existing config with --init-config",
+    )
+    parser.add_argument(
+        "--config-path",
+        default=str(Path.home() / ".config" / "redmine-reporter" / "config.yml"),
+        help="Path for --init-config output (default: ~/.config/redmine-reporter/config.yml)",
+    )
+    parser.add_argument(
+        "--commit",
+        action="store_true",
+        help="Save used period as last_used in YAML config and auto-commit to file",
+    )
     args = parser.parse_args(argv)
 
+    # --init-config: обработка до всего остального
+    if args.init_config:
+        # Проверка на взаимоисключающие флаги
+        report_flags = [
+            args.date is not None,
+            args.output,
+            args.compact,
+            args.summary,
+            args.user_id,
+            args.user_login,
+            args.user_name,
+            args.no_time,
+            args.by_activity,
+        ]
+        if any(report_flags):
+            print(
+                "❌ --init-config cannot be used with report-generating flags.",
+                file=sys.stderr,
+            )
+            return 1
+        return _run_init_config(args.config_path, args.force)
+
     # Валидация взаимоисключающих флагов пользователя
     user_args = [args.user_id, args.user_login, args.user_name]
     if sum(bool(a) for a in user_args) > 1:
@@ -105,6 +239,10 @@ def main(argv: Optional[List[str]] = None) -> int:
     Config.set_redmine_url(args.url)
     Config.set_redmine_api_key(args.api_key)
 
+    # Автозагрузка YAML-конфига
+    yaml_path = args.config_path
+    Config.load_yaml(yaml_path)
+
     # Настройка уровня логирования
     if args.debug:
         logging.basicConfig(level=logging.DEBUG, format="%(levelname)s: %(message)s")
@@ -119,8 +257,10 @@ def main(argv: Optional[List[str]] = None) -> int:
         print(f"❌ Configuration error: {e}", file=sys.stderr)
         return 1
 
+    # Если --date не указан, используем дефолтный диапазон
+    date_arg = args.date if args.date is not None else Config.get_default_date_range()
     try:
-        from_date, to_date = parse_date_range(args.date)
+        from_date, to_date = parse_date_range(date_arg)
     except ValueError as e:
         print(f"❌ Date error: {e}", file=sys.stderr)
         return 1
@@ -130,6 +270,8 @@ def main(argv: Optional[List[str]] = None) -> int:
             from_date,
             to_date,
             user_id=args.user_id or args.user_login or args.user_name,
+            by_activity=args.by_activity,
+            dedup_before=_compute_dedup_cutoff(),
         )
     except RedmineAPIError as e:
         print(f"❌ {e.message}", file=sys.stderr)
@@ -148,20 +290,47 @@ def main(argv: Optional[List[str]] = None) -> int:
         print("ℹ️  No time entries found in the given period.", file=sys.stderr)
         return 0
 
-    print(f"✅ Total issues: {len(issue_hours)} [{args.date}]", file=sys.stderr)
+    print(f"✅ Total issues: {len(issue_hours)} [{date_arg}]", file=sys.stderr)
 
-    rows = build_grouped_report(issue_hours, fill_time=not args.no_time)
+    rows = build_grouped_report(
+        issue_hours,
+        fill_time=not args.no_time,
+        by_activity=args.by_activity,
+    )
 
     if args.summary:
-        summary = calculate_summary(rows)
+        summary = calculate_summary(rows, by_activity=args.by_activity)
         print(f"⏱️  Total time: {summary['total']}h", file=sys.stderr)
-        for key, value in summary.items():
+        project_keys = [k for k in sorted(summary) if k.startswith("project:")]
+        activity_keys = [k for k in sorted(summary) if k.startswith("activity:")]
+        for key in project_keys + activity_keys:
+            value = summary[key]
             if key.startswith("project:"):
                 project = key.split(":", 1)[1]
                 print(f"   {project}: {value}h", file=sys.stderr)
+            elif key.startswith("activity:"):
+                activity = key.split(":", 1)[1]
+                print(f"   [{activity}]: {value}h", file=sys.stderr)
 
     if args.output:
-        output_ext = os.path.splitext(args.output)[1].lower()
+        output_arg = resolve_output_path(
+            args.output,
+            output_dir=Config.get_output_dir(),
+            filename_template=Config.get_output_filename(),
+            default_format=Config.get_output_default_format(),
+            author=Config.get_author(args.author),
+            from_date=from_date,
+            to_date=to_date,
+        )
+
+        if output_arg is None:
+            print(
+                "❌ Файл без расширения. Укажите расширение: .odt, .csv, .md, .html, .json или .xlsx",
+                file=sys.stderr,
+            )
+            return 1
+
+        output_ext = os.path.splitext(output_arg)[1].lower()
 
         if not output_ext:
             print(
@@ -194,13 +363,49 @@ def main(argv: Optional[List[str]] = None) -> int:
             return 1
 
         try:
-            formatter.save(rows, args.output)
+            formatter.save(rows, output_arg)
-            print(f"✅ Report saved to {args.output}")
+            print(f"✅ Report saved to {output_arg}")
         except Exception as e:
             fmt = output_ext.lstrip(".").upper()
             print(f"❌ {fmt} export error: {e}", file=sys.stderr)
             return 1
 
+    elif args.commit:
+        default_format = Config.get_output_default_format()
+        output_arg = resolve_output_path(
+            default_format,
+            output_dir=Config.get_output_dir(),
+            filename_template=Config.get_output_filename(),
+            default_format=default_format,
+            author=Config.get_author(args.author),
+            from_date=from_date,
+            to_date=to_date,
+        )
+
+        if output_arg is None:
+            print("❌ Не удалось определить путь для сохранения отчёта.", file=sys.stderr)
+            return 1
+
+        output_ext = os.path.splitext(output_arg)[1].lower()
+        formatter = get_formatter_by_extension(
+            output_ext,
+            author=Config.get_author(args.author),
+            from_date=from_date,
+            to_date=to_date,
+            no_time=args.no_time,
+        )
+
+        if not formatter:
+            print(f"❌ Не удалось создать форматтер для {output_ext}", file=sys.stderr)
+            return 1
+
+        try:
+            formatter.save(rows, output_arg)
+            print(f"✅ Report saved to {output_arg}")
+        except Exception as e:
+            print(f"❌ Export error: {e}", file=sys.stderr)
+            return 1
+
     else:
         if args.compact:
             formatter = get_console_formatter("compact")
@@ -218,6 +423,26 @@ def main(argv: Optional[List[str]] = None) -> int:
             print(f"❌ Formatting error: {e}", file=sys.stderr)
             return 1
 
+    if args.commit:
+        precision = Config.get_period_precision()
+        dynamic = Config._app.period_dynamic if Config._app else False
+
+        if precision == "datetime":
+            from datetime import datetime as dt_mod
+
+            now = dt_mod.now().isoformat(timespec="seconds")
+            from_str = now
+            to_str = now
+        else:
+            from_str = from_date
+            to_str = to_date
+
+        save_period_to_config(args.config_path, from_str, to_str, precision, dynamic)
+        print(
+            f"📌 Period committed [{from_str} -- {to_str}] → {args.config_path}",
+            file=sys.stderr,
+        )
+
     return 0
 
 

redmine_reporter/client.py

@@ -1,3 +1,4 @@
+from datetime import datetime
 from typing import Any, Dict, List, Optional, Tuple, Union
 
 import requests
@@ -111,6 +112,58 @@ def _format_redmine_error(exc: Exception) -> str:
     return str(exc)
 
 
+def _load_time_entry_activities(redmine: Redmine) -> Dict[int, str]:
+    """Загружает справочник типов активности time entries.
+
+    Возвращает словарь id -> name. Если справочник недоступен,
+    возвращает пустой словарь — тогда будем использовать данные из самих entries.
+    """
+    try:
+        activities = redmine.enumeration.filter(resource="time_entry_activities")
+        return {int(a.id): str(a.name) for a in activities}
+    except Exception:
+        return {}
+
+
+def _get_activity_name(entry, activities: Dict[int, str]) -> str:
+    """Определяет название активности для time entry."""
+    activity = getattr(entry, "activity", None)
+    if activity is None:
+        return "<N/A>"
+
+    # activity может быть объектом с id/name или просто значением
+    activity_id = getattr(activity, "id", None)
+    if activity_id is not None:
+        name = activities.get(int(activity_id))
+        if name:
+            return name
+        activity_name = getattr(activity, "name", None)
+        if activity_name:
+            return str(activity_name)
+        return str(activity_id)
+
+    return str(activity)
+
+
+def _parse_datetime(value: Any) -> Optional[datetime]:
+    """Parse a datetime from Redmine API response.
+
+    Accepts datetime objects, ISO strings (with or without timezone),
+    or None. Returns a timezone-aware datetime or None.
+    """
+    if value is None:
+        return None
+    if isinstance(value, datetime):
+        return value
+    if isinstance(value, str):
+        try:
+            dt = datetime.fromisoformat(value.replace("Z", "+00:00"))
+            return dt
+        except (ValueError, TypeError):
+            return None
+    return None
+
+
 def _fetch_issues_chunked(redmine: Redmine, issue_ids: List[int]) -> List[Issue]:
     """Загружает задачи чанками, чтобы не превышать лимит длины URL (#21)."""
     all_issues: List[Issue] = []
@@ -186,12 +239,17 @@ def fetch_issues_with_spent_time(
     from_date: str,
     to_date: str,
     user_id: Optional[Union[int, str]] = None,
-) -> Optional[List[Tuple[Issue, float]]]:
+    by_activity: bool = False,
+    dedup_before: Optional[datetime] = None,
+) -> Optional[List[Tuple[Issue, float, Optional[Dict[str, float]]]]]:
     """
     Fetch unique issues linked to time entries of the given user in date range,
     along with total spent hours per issue.
     If user_id is None, uses current user.
-    Returns list of (issue, total_hours) tuples.
+    If by_activity is True, returns per-activity breakdown as third tuple element.
+    If dedup_before is set, filters out time entries whose created_on AND updated_on
+    are both before dedup_before (AND logic: both must be < cutoff to exclude).
+    Returns list of (issue, total_hours, activities) tuples.
     Raises RedmineAPIError on API/auth/network failures.
     """
 
@@ -202,22 +260,50 @@ def fetch_issues_with_spent_time(
             if user_id is not None
             else _get_current_user_id(redmine)
         )
-        time_entries = redmine.time_entry.filter(
+        activities_lookup = _load_time_entry_activities(redmine) if by_activity else {}
-            user_id=target_user_id, from_date=from_date, to_date=to_date
+        time_entries = list(
+            redmine.time_entry.filter(user_id=target_user_id, from_date=from_date, to_date=to_date)
         )
     except RedmineAPIError:
         raise
     except Exception as exc:
         raise RedmineAPIError(_format_redmine_error(exc), original=exc) from exc
 
-    # Агрегируем часы по issue.id
+    # Дедупликация: отсекаем записи, которые были учтены в предыдущем отчёте.
+    # Запись исключается, если BOTH created_on AND updated_on < dedup_before.
+    # Записи без метаданных (created_on/updated_on == None) не фильтруются.
+    if dedup_before is not None:
+        filtered: list = []
+        for entry in time_entries:
+            created = _parse_datetime(getattr(entry, "created_on", None))
+            updated = _parse_datetime(getattr(entry, "updated_on", None))
+
+            if created is None and updated is None:
+                filtered.append(entry)
+            elif created is not None and updated is not None:
+                if created >= dedup_before and updated >= dedup_before:
+                    filtered.append(entry)
+            elif created is not None and created >= dedup_before:
+                filtered.append(entry)
+            elif updated is not None and updated >= dedup_before:
+                filtered.append(entry)
+        time_entries = filtered
+
+    # Агрегируем часы по issue.id (и активности, если требуется)
     spent_time: Dict[int, float] = {}
+    spent_by_activity: Dict[int, Dict[str, float]] = {}
     issue_ids = set()
     for entry in time_entries:
         if hasattr(entry, "issue") and entry.issue and hasattr(entry, "hours"):
             iid = entry.issue.id
+            hours = float(entry.hours)
             issue_ids.add(iid)
-            spent_time[iid] = spent_time.get(iid, 0.0) + float(entry.hours)
+            spent_time[iid] = spent_time.get(iid, 0.0) + hours
+
+            if by_activity:
+                activity_name = _get_activity_name(entry, activities_lookup)
+                by_act = spent_by_activity.setdefault(iid, {})
+                by_act[activity_name] = by_act.get(activity_name, 0.0) + hours
 
     if not issue_ids:
         return None
@@ -234,7 +320,11 @@ def fetch_issues_with_spent_time(
     # здесь оставляем порядок API как есть.
     result = []
     for issue in issues:
-        total_hours = spent_time.get(issue.id, 0.0)
+        iid = issue.id
-        result.append((issue, total_hours))
+        if iid not in spent_time:
+            continue
+        total_hours = spent_time[iid]
+        activity_breakdown = spent_by_activity.get(iid) if by_activity else None
+        result.append((issue, total_hours, activity_breakdown))
 
     return result

redmine_reporter/config.py

@@ -1,19 +1,243 @@
+import logging
 import os
+from dataclasses import dataclass, field
 from datetime import date, timedelta
+from pathlib import Path
 from typing import Union
 
+import yaml
 from dotenv import load_dotenv
 
+from .yaml_config import check_file_permissions, resolve_env_vars
+
 load_dotenv(override=False)
 
+logger = logging.getLogger(__name__)
+
 DEFAULT_REDMINE_VERIFY = "/etc/ssl/certs/ca-certificates.crt"
 FALSE_VALUES = {"0", "false", "no", "off"}
 TRUE_VALUES = {"1", "true", "yes", "on"}
 
 
+@dataclass
+class SmtpConfig:
+    host: str = ""
+    port: int = 587
+    user: str = ""
+    password: str = ""
+    tls: bool = True
+
+
+@dataclass
+class EmailConfig:
+    smtp: SmtpConfig = field(default_factory=SmtpConfig)
+    from_: str = ""
+    to: list = field(default_factory=list)
+    cc: list = field(default_factory=list)
+    bcc: list = field(default_factory=list)
+    subject: str = "Отчёт {author} за {period}"
+    body_text: str = "Во вложении отчёт."
+    attach: bool = True
+
+
+@dataclass
+class PeriodLastUsed:
+    from_: str = ""
+    to: str = ""
+
+
+@dataclass
+class AppConfig:
+    redmine_url: str = ""
+    redmine_api_key: str = ""
+    redmine_author: str = ""
+    redmine_verify: Union[bool, str] = DEFAULT_REDMINE_VERIFY
+    period_precision: str = "date"
+    period_default_from: str = ""
+    period_default_to: str = ""
+    period_dynamic: bool = False
+    period_last_used_from: str = ""
+    period_last_used_to: str = ""
+    output_dir: str = ""
+    output_filename: str = "{author}_{from}_{to}.{ext}"
+    output_default_format: str = "xlsx"
+    email: EmailConfig = field(default_factory=EmailConfig)
+
+    @classmethod
+    def from_yaml(cls, path: Union[str, Path]) -> "AppConfig":
+        """Загружает настройки из YAML-файла.
+
+        Если файл не существует — возвращает конфиг со значениями по умолчанию.
+        Неизвестные ключи верхнего уровня логируются с warning.
+        """
+        path = Path(path)
+        if not path.exists():
+            return cls()
+
+        # Проверяем права файла
+        for warning in check_file_permissions(path):
+            logger.warning(warning)
+
+        with open(path, "r", encoding="utf-8") as fh:
+            raw = yaml.safe_load(fh) or {}
+
+        # Предупреждаем о неизвестных ключах верхнего уровня
+        known_keys = {
+            "redmine",
+            "period",
+            "output",
+            "email",
+        }
+        for key in raw:
+            if key not in known_keys:
+                logger.warning("Unknown top-level key in config: %s", key)
+
+        return cls(
+            redmine_url=cls._resolve_str(raw, "redmine", "url"),
+            redmine_api_key=cls._resolve_str(raw, "redmine", "api_key"),
+            redmine_author=cls._resolve_str(raw, "redmine", "author"),
+            redmine_verify=cls._resolve_verify(raw),
+            period_precision=cls._resolve_str(raw, "period", "precision") or "date",
+            period_default_from=cls._resolve_str(raw, "period", "default_from"),
+            period_default_to=cls._resolve_str(raw, "period", "default_to"),
+            period_dynamic=cls._resolve_bool(raw, "period", "dynamic"),
+            period_last_used_from=cls._resolve_str(raw, "period", "last_used", "from"),
+            period_last_used_to=cls._resolve_str(raw, "period", "last_used", "to"),
+            output_dir=cls._resolve_str(raw, "output", "dir"),
+            output_filename=cls._resolve_str(raw, "output", "filename")
+            or "{author}_{from}_{to}.{ext}",
+            output_default_format=cls._resolve_str(raw, "output", "default_format") or "xlsx",
+            email=cls._resolve_email(raw),
+        )
+
+    @classmethod
+    def from_env(cls) -> "AppConfig":
+        """Загружает настройки из переменных окружения."""
+        return cls(
+            redmine_url=os.getenv("REDMINE_URL", "").strip().rstrip("/"),
+            redmine_api_key=os.getenv("REDMINE_API_KEY", "").strip(),
+            redmine_author=os.getenv("REDMINE_AUTHOR", "").strip(),
+            period_default_from=os.getenv("DEFAULT_FROM_DATE", "").strip(),
+            period_default_to=os.getenv("DEFAULT_TO_DATE", "").strip(),
+        )
+
+    @staticmethod
+    def _resolve_str(raw: dict, section: str, *keys: str) -> str:
+        value = raw.get(section)
+        for key in keys:
+            if isinstance(value, dict):
+                value = value.get(key)
+            else:
+                value = None
+                break
+        if isinstance(value, str):
+            return resolve_env_vars(value)
+        if value is None:
+            return ""
+        return str(value)
+
+    @staticmethod
+    def _resolve_bool(raw: dict, section: str, key: str) -> bool:
+        value = raw.get(section, {}).get(key)
+        if isinstance(value, bool):
+            return value
+        if isinstance(value, str):
+            normalized = value.lower()
+            if normalized in TRUE_VALUES:
+                return True
+            if normalized in FALSE_VALUES:
+                return False
+        return False
+
+    @classmethod
+    def _resolve_verify(cls, raw: dict) -> Union[bool, str]:
+        value = raw.get("redmine", {}).get("verify_ssl")
+        if value is None:
+            return DEFAULT_REDMINE_VERIFY
+        if isinstance(value, bool):
+            return DEFAULT_REDMINE_VERIFY if value else False
+        if isinstance(value, str):
+            normalized = value.lower()
+            if normalized in FALSE_VALUES:
+                return False
+            if normalized in TRUE_VALUES:
+                return DEFAULT_REDMINE_VERIFY
+            return resolve_env_vars(value)
+        return DEFAULT_REDMINE_VERIFY
+
+    @classmethod
+    def _resolve_email(cls, raw: dict) -> EmailConfig:
+        email_raw = raw.get("email", {}) or {}
+        smtp_raw = email_raw.get("smtp", {}) or {}
+
+        return EmailConfig(
+            smtp=SmtpConfig(
+                host=cls._safe_str(smtp_raw.get("host")),
+                port=cls._safe_int(smtp_raw.get("port"), 587),
+                user=cls._safe_str(smtp_raw.get("user")),
+                password=resolve_env_vars(cls._safe_str(smtp_raw.get("password"))),
+                tls=cls._safe_bool(smtp_raw.get("tls"), True),
+            ),
+            from_=cls._safe_str(email_raw.get("from")),
+            to=cls._safe_list(email_raw.get("to")),
+            cc=cls._safe_list(email_raw.get("cc")),
+            bcc=cls._safe_list(email_raw.get("bcc")),
+            subject=resolve_env_vars(
+                cls._safe_str(email_raw.get("subject")) or "Отчёт {author} за {period}"
+            ),
+            body_text=resolve_env_vars(
+                cls._safe_str(email_raw.get("body_text")) or "Во вложении отчёт."
+            ),
+            attach=cls._safe_bool(email_raw.get("attach"), True),
+        )
+
+    @staticmethod
+    def _safe_str(value) -> str:
+        if value is None:
+            return ""
+        if isinstance(value, str):
+            return value
+        return str(value)
+
+    @staticmethod
+    def _safe_int(value, default: int = 0) -> int:
+        if value is None:
+            return default
+        try:
+            return int(value)
+        except (TypeError, ValueError):
+            return default
+
+    @staticmethod
+    def _safe_bool(value, default: bool = False) -> bool:
+        if isinstance(value, bool):
+            return value
+        if isinstance(value, str):
+            normalized = value.lower()
+            if normalized in TRUE_VALUES:
+                return True
+            if normalized in FALSE_VALUES:
+                return False
+        return default
+
+    @staticmethod
+    def _safe_list(value) -> list:
+        if value is None:
+            return []
+        if isinstance(value, list):
+            return [str(v) for v in value]
+        return [str(value)]
+
+
 class Config:
     _cli_url: str | None = None
     _cli_api_key: str | None = None
+    _app: AppConfig | None = None
+
+    @classmethod
+    def load_yaml(cls, path: str) -> None:
+        """Загружает YAML-конфиг. Не бросает исключений при отсутствии файла."""
+        cls._app = AppConfig.from_yaml(path)
 
     @classmethod
     def load_config(cls, path: str) -> None:
@@ -32,13 +256,23 @@ class Config:
     def get_redmine_url(cls) -> str:
         if cls._cli_url is not None:
             return cls._cli_url
-        return os.getenv("REDMINE_URL", "").strip().rstrip("/")
+        env = os.getenv("REDMINE_URL", "").strip().rstrip("/")
+        if env:
+            return env
+        if cls._app:
+            return cls._app.redmine_url.strip().rstrip("/")
+        return ""
 
     @classmethod
     def get_redmine_api_key(cls) -> str:
         if cls._cli_api_key is not None:
             return cls._cli_api_key
-        return os.getenv("REDMINE_API_KEY", "").strip()
+        env = os.getenv("REDMINE_API_KEY", "").strip()
+        if env:
+            return env
+        if cls._app:
+            return cls._app.redmine_api_key
+        return ""
 
     @classmethod
     def get_redmine_user(cls) -> str:
@@ -51,34 +285,89 @@ class Config:
     @classmethod
     def get_redmine_verify(cls) -> Union[bool, str]:
         value = os.getenv("REDMINE_VERIFY", "").strip()
-        if not value:
+        if value:
-            return DEFAULT_REDMINE_VERIFY
+            normalized = value.lower()
-
+            if normalized in FALSE_VALUES:
-        normalized = value.lower()
+                return False
-        if normalized in FALSE_VALUES:
+            if normalized in TRUE_VALUES:
-            return False
+                return True
-        if normalized in TRUE_VALUES:
+            return value
-            return True
+        if cls._app:
-        return value
+            return cls._app.redmine_verify
+        return DEFAULT_REDMINE_VERIFY
 
     @classmethod
     def get_author(cls, cli_author: str = "") -> str:
-        """Возвращает автора: из CLI если задан, иначе из .env, иначе — заглушку."""
         if cli_author:
             return cli_author
-        return os.getenv("REDMINE_AUTHOR", "").strip()
+        env = os.getenv("REDMINE_AUTHOR", "").strip()
+        if env:
+            return env
+        if cls._app:
+            return cls._app.redmine_author
+        return ""
+
+    @classmethod
+    def get_period_precision(cls) -> str:
+        if cls._app:
+            return cls._app.period_precision or "date"
+        return "date"
+
+    @classmethod
+    def get_last_used_from(cls) -> str:
+        if cls._app:
+            return cls._app.period_last_used_from
+        return ""
+
+    @classmethod
+    def get_last_used_to(cls) -> str:
+        if cls._app:
+            return cls._app.period_last_used_to
+        return ""
+
+    @classmethod
+    def get_output_dir(cls) -> str:
+        if cls._app:
+            return cls._app.output_dir
+        return ""
+
+    @classmethod
+    def get_output_filename(cls) -> str:
+        if cls._app:
+            return cls._app.output_filename or "{author}_{from}_{to}.{ext}"
+        return "{author}_{from}_{to}.{ext}"
+
+    @classmethod
+    def get_output_default_format(cls) -> str:
+        if cls._app:
+            return cls._app.output_default_format or "xlsx"
+        return "xlsx"
 
     @classmethod
     def get_default_date_range(cls) -> str:
-        default_from_date = os.getenv("DEFAULT_FROM_DATE", "").strip()
+        from_env = os.getenv("DEFAULT_FROM_DATE", "").strip()
-        default_to_date = os.getenv("DEFAULT_TO_DATE", "").strip()
+        to_env = os.getenv("DEFAULT_TO_DATE", "").strip()
-        if default_from_date and default_to_date:
+        if from_env and to_env:
-            return f"{default_from_date}--{default_to_date}"
+            return f"{from_env}--{to_env}"
+
+        if (
+            cls._app
+            and cls._app.period_dynamic
+            and cls._app.period_last_used_from
+            and cls._app.period_last_used_to
+        ):
+            nf, nt = compute_next_period(
+                cls._app.period_last_used_from,
+                cls._app.period_last_used_to,
+                cls._app.period_precision or "date",
+            )
+            return f"{nf}--{nt}"
+
+        if cls._app and cls._app.period_default_from and cls._app.period_default_to:
+            return f"{cls._app.period_default_from}--{cls._app.period_default_to}"
 
-        # fallback: текущий месяц
         today = date.today()
         start = today.replace(day=1)
-        # последний день месяца: берём первое число следующего месяца и вычитаем день
         if today.month == 12:
             next_month = today.replace(year=today.year + 1, month=1, day=1)
         else:
@@ -96,3 +385,50 @@ class Config:
             raise ValueError(
                 "REDMINE_API_KEY is required, or set both REDMINE_USER and REDMINE_PASSWORD"
             )
+
+
+def compute_next_period(last_from: str, last_to: str, precision: str) -> tuple[str, str]:
+    """Compute the next report period based on the last committed period.
+
+    - For a full calendar month → next full calendar month.
+    - For an arbitrary range → same duration, starting the day after last_to.
+    - For datetime precision → same duration, starting 1 second after last_to.
+    """
+    from datetime import datetime as dt_mod
+
+    if precision == "datetime":
+        fmt = "%Y-%m-%dT%H:%M:%S"
+        from_dt = dt_mod.fromisoformat(last_from.replace("Z", "+00:00"))
+        to_dt = dt_mod.fromisoformat(last_to.replace("Z", "+00:00"))
+        duration = to_dt - from_dt
+        next_from_dt = to_dt + timedelta(seconds=1)
+        next_to_dt = next_from_dt + duration
+        return next_from_dt.strftime(fmt), next_to_dt.strftime(fmt)
+
+    from_parts = last_from.split("-")
+    to_parts = last_to.split("-")
+    from_d = date(int(from_parts[0]), int(from_parts[1]), int(from_parts[2]))
+    to_d = date(int(to_parts[0]), int(to_parts[1]), int(to_parts[2]))
+
+    first_of_month = from_d.replace(day=1)
+    if from_d == first_of_month:
+        if to_d.month == 12:
+            last_of_month = date(to_d.year, 12, 31)
+        else:
+            next_first = date(to_d.year, to_d.month + 1, 1)
+            last_of_month = next_first - timedelta(days=1)
+        if to_d == last_of_month:
+            if to_d.month == 12:
+                nstart = date(to_d.year + 1, 1, 1)
+            else:
+                nstart = date(to_d.year, to_d.month + 1, 1)
+            if nstart.month == 12:
+                nend = date(nstart.year, 12, 31)
+            else:
+                nend = date(nstart.year, nstart.month + 1, 1) - timedelta(days=1)
+            return nstart.isoformat(), nend.isoformat()
+
+    duration = to_d - from_d
+    next_from = to_d + timedelta(days=1)
+    next_to = next_from + duration
+    return next_from.isoformat(), next_to.isoformat()

redmine_reporter/formatters/console.py

@@ -12,13 +12,14 @@ class TableFormatter(Formatter):
     def format(self, rows: List[ReportRow]) -> str:
         table_rows = [["Проект", "Версия", "Задача", "Статус", "Затрачено"]]
         for r in rows:
+            time_text = r["time_text"].replace("\n", " / ")
             table_rows.append(
                 [
                     r["display_project"],
                     r["display_version"],
                     f"{r['issue_id']}. {r['subject']}",
                     r["status_ru"],
-                    r["time_text"],
+                    time_text,
                 ]
             )
         return tabulate(table_rows, headers="firstrow", tablefmt="fancy_grid")
@@ -35,9 +36,10 @@ class CompactFormatter(Formatter):
     def format(self, rows: List[ReportRow]) -> str:
         lines = []
         for r in rows:
+            time_text = r["time_text"].replace("\n", " / ")
             lines.append(
                 f"{r['display_project']} | {r['display_version']} | "
-                f"{r['issue_id']}. {r['subject']} | {r['status_ru']} | {r['time_text']}"
+                f"{r['issue_id']}. {r['subject']} | {r['status_ru']} | {time_text}"
             )
         return "\n".join(lines)
 

redmine_reporter/formatters/csv.py

@@ -27,6 +27,7 @@ class CSVFormatter(Formatter):
             headers.append("Spent Time")
         writer.writerow(headers)
         for r in rows:
+            time_text = r["time_text"].replace("\n", " / ")
             data = [
                 r["project"],
                 r["version"],
@@ -35,7 +36,7 @@ class CSVFormatter(Formatter):
                 r["status_ru"],
             ]
             if not self.no_time:
-                data.append(r["time_text"])
+                data.append(time_text)
             writer.writerow(data)
         return output.getvalue()
 

redmine_reporter/formatters/html.py

@@ -48,7 +48,7 @@ class HTMLFormatter(Formatter):
                 for r in task_rows:
                     task_cell = escape(f"{r['issue_id']}. {r['subject']}")
                     status_text = escape(r["status_ru"])
-                    time_text = escape(r["time_text"])
+                    time_text = escape(r["time_text"]).replace("\n", "<br>")
                     lines.append("    <tr>")
 
                     # Ячейка "Проект" - только в первой строке проекта

redmine_reporter/formatters/json.py

@@ -12,8 +12,9 @@ class JSONFormatter(Formatter):
         super().__init__()
 
     def format(self, rows: List[ReportRow]) -> str:
-        data = [
+        data = []
-            {
+        for r in rows:
+            item = {
                 "project": r["project"],
                 "version": r["version"],
                 "issue_id": r["issue_id"],
@@ -21,8 +22,10 @@ class JSONFormatter(Formatter):
                 "status": r["status_ru"],
                 "time": r["time_text"],
             }
-            for r in rows
+            activities = r.get("activities")
-        ]
+            if activities:
+                item["activities"] = activities
+            data.append(item)
         return json.dumps(data, ensure_ascii=False, indent=2)
 
     def save(self, rows: List[ReportRow], output_path: str) -> None:

redmine_reporter/formatters/odt.py

@@ -31,6 +31,13 @@ class ODTFormatter(Formatter):
         with resources.files("redmine_reporter").joinpath("templates/template.odt").open("rb") as f:
             doc = load(f)
 
+        # Удаляем все текстовые параграфы из шаблона, оставляя только
+        # структурные элементы (forms, sequence-decls).  Это защищает от
+        # артефактов редактирования шаблона в LibreOffice (#42).
+        for child in list(doc.text.childNodes):
+            if child.tagName == "text:p":
+                doc.text.removeChild(child)
+
         para_style_name = "Standard"
 
         # Заголовок
@@ -125,8 +132,12 @@ class ODTFormatter(Formatter):
                     row.addElement(status_cell)
 
                     time_cell = TableCell(stylename=cell_style_name)
-                    p = P(stylename=para_style_name, text=r["time_text"])
+                    time_lines = r["time_text"].split("\n")
-                    time_cell.addElement(p)
+                    for i, line in enumerate(time_lines):
+                        p = P(stylename=para_style_name, text=line)
+                        time_cell.addElement(p)
+                        if i < len(time_lines) - 1:
+                            time_cell.addElement(P(stylename=para_style_name, text=""))
                     row.addElement(time_cell)
 
                     table.addElement(row)

redmine_reporter/report_builder.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, Tuple, cast
+from typing import Dict, List, Optional, Tuple, cast
 
 from redminelib.resources import Issue
 
@@ -22,9 +22,19 @@ STATUS_TRANSLATION = {
 }
 
 
+def _format_activities(activities: Dict[str, float]) -> str:
+    """Форматирует разбивку по активностям в многострочный текст."""
+    if not activities:
+        return ""
+    # Сортируем по убыванию часов, затем по алфавиту для стабильности
+    items = sorted(activities.items(), key=lambda x: (-x[1], x[0]))
+    return "\n".join(f"{hours_to_human(hours)} {name}" for name, hours in items)
+
+
 def build_grouped_report(
-    issue_hours: List[Tuple[Issue, float]],
+    issue_hours: List[Tuple[Issue, float, Optional[Dict[str, float]]]],
     fill_time: bool = True,
+    by_activity: bool = False,
 ) -> List[ReportRow]:
     """
     Преобразует список задач с затраченным временем в плоский список строк отчёта,
@@ -41,12 +51,20 @@ def build_grouped_report(
     prev_project: str = ""
     prev_version: str = ""
 
-    for issue, hours in issue_hours:
+    for issue, hours, *rest in issue_hours:
+        activities: Optional[Dict[str, float]] = rest[0] if rest else None
         project = str(issue.project)
         version = get_version(issue)
         status_en = str(issue.status)
         status_ru = STATUS_TRANSLATION.get(status_en, status_en)
-        time_text = hours_to_human(hours) if fill_time else ""
+
+        if fill_time:
+            if by_activity and activities:
+                time_text = _format_activities(activities)
+            else:
+                time_text = hours_to_human(hours)
+        else:
+            time_text = ""
 
         display_project = project if project != prev_project else ""
         display_version = version if (project != prev_project or version != prev_version) else ""
@@ -64,6 +82,7 @@ def build_grouped_report(
                     "status_ru": status_ru,
                     "time_text": time_text,
                     "hours": round(hours, 2),
+                    "activities": activities,
                 },
             )
         )
@@ -74,11 +93,15 @@ def build_grouped_report(
     return rows
 
 
-def calculate_summary(rows: List[ReportRow]) -> Dict[str, float]:
+def calculate_summary(
-    """Возвращает сводку: общее время, время по проектам и версиям."""
+    rows: List[ReportRow],
+    by_activity: bool = False,
+) -> Dict[str, float]:
+    """Возвращает сводку: общее время, время по проектам, версиям и активностям."""
     total = 0.0
     by_project: Dict[str, float] = {}
     by_project_version: Dict[str, float] = {}
+    by_activity_name: Dict[str, float] = {}
 
     for r in rows:
         hours = r.get("hours", 0.0)
@@ -87,11 +110,21 @@ def calculate_summary(rows: List[ReportRow]) -> Dict[str, float]:
         key = f"{r['project']}::{r['version']}"
         by_project_version[key] = by_project_version.get(key, 0.0) + hours
 
-    return {
+        if by_activity:
+            activities = r.get("activities")
+            if activities:
+                for name, act_hours in activities.items():
+                    by_activity_name[name] = by_activity_name.get(name, 0.0) + act_hours
+
+    result: Dict[str, float] = {
         "total": round(total, 2),
         **{f"project:{k}": round(v, 2) for k, v in by_project.items()},
         **{f"version:{k}": round(v, 2) for k, v in by_project_version.items()},
     }
+    if by_activity:
+        result.update({f"activity:{k}": round(v, 2) for k, v in by_activity_name.items()})
+
+    return result
 
 
 def group_rows_by_project_and_version(

redmine_reporter/types.py

@@ -1,7 +1,7 @@
-from typing import TypedDict
+from typing import Dict, Optional, TypedDict
 
 
-class ReportRow(TypedDict):
+class ReportRowBase(TypedDict):
     """Строка итогового отчёта."""
 
     project: str
@@ -13,3 +13,9 @@ class ReportRow(TypedDict):
     status_ru: str
     time_text: str
     hours: float
+
+
+class ReportRow(ReportRowBase, total=False):
+    """Строка итогового отчёта с опциональной разбивкой по активностям."""
+
+    activities: Optional[Dict[str, float]]

redmine_reporter/yaml_config.py

@@ -0,0 +1,186 @@
+import logging
+import os
+import re
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+_ENV_VAR_RE = re.compile(r"\$\{([^}]+)\}")
+
+
+def resolve_env_vars(value: str) -> str:
+    """Replace ${VAR} patterns with environment variable values.
+
+    Non-recursive: if ${A} expands to a literal ${B}, ${B} is NOT resolved.
+    Unknown variables are replaced with empty string and a warning is logged.
+    """
+    if not isinstance(value, str):
+        return value
+
+    def _replacer(match: re.Match) -> str:
+        var_name = match.group(1)
+        env_value = os.environ.get(var_name)
+        if env_value is None:
+            logger.warning("Environment variable %s is not set, using empty string", var_name)
+            return ""
+        return env_value
+
+    return _ENV_VAR_RE.sub(_replacer, value)
+
+
+def ensure_config_dir(path: Path | None = None) -> Path:
+    """Create ~/.config/redmine-reporter/ with 0o700 permissions.
+
+    Returns the path to the config directory.
+    No-op if the directory already exists.
+    """
+    if path is None:
+        path = Path.home() / ".config" / "redmine-reporter"
+    path.mkdir(mode=0o700, parents=True, exist_ok=True)
+    return path
+
+
+def check_file_permissions(path: Path) -> list[str]:
+    """Check that a config file has safe permissions (0o600 or stricter).
+
+    Returns a list of warning messages. Empty list means no issues.
+    """
+    warnings: list[str] = []
+    if not path.exists():
+        return warnings
+
+    mode = path.stat().st_mode & 0o777
+    if mode > 0o600:
+        warnings.append(
+            f"Config file permissions are too open ({mode:04o}). "
+            f"Expected 0600. Fix with: chmod 600 {path}"
+        )
+    return warnings
+
+
+def expand_filename_template(
+    template: str,
+    *,
+    author: str = "",
+    from_date: str = "",
+    to_date: str = "",
+    ext: str = "",
+) -> str:
+    """Expand placeholders in a filename template.
+
+    Supported placeholders:
+      {author}  — author name
+      {from}    — start date (YYYY-MM-DD)
+      {to}      — end date (YYYY-MM-DD)
+      {date}    — end date formatted as DD_MM_YYYY
+      {ext}     — file extension without dot
+
+    Unknown placeholders are left as-is.
+    """
+    date_dd_mm_yyyy = ""
+    if to_date:
+        try:
+            from datetime import datetime
+
+            dt = datetime.strptime(to_date, "%Y-%m-%d")
+            date_dd_mm_yyyy = dt.strftime("%d_%m_%Y")
+        except ValueError:
+            date_dd_mm_yyyy = to_date
+
+    replacements = {
+        "author": author.replace(" ", "_"),
+        "from": from_date,
+        "to": to_date,
+        "date": date_dd_mm_yyyy,
+        "ext": ext,
+    }
+
+    result = template
+    for key, value in replacements.items():
+        result = result.replace("{" + key + "}", value)
+    return result
+
+
+KNOWN_FORMAT_NAMES = {"xlsx", "odt", "csv", "md", "html", "json"}
+
+
+def resolve_output_path(
+    output_arg: str | None,
+    *,
+    output_dir: str = "",
+    filename_template: str = "{author}_{from}_{to}.{ext}",
+    default_format: str = "xlsx",
+    author: str = "",
+    from_date: str = "",
+    to_date: str = "",
+) -> str | None:
+    """Resolve the final output path from --output argument and config settings.
+
+    Returns None if output_arg is None (meaning no file output, use console).
+
+    Resolution rules:
+      - None → None (console output)
+      - Bare format name (xlsx, odt, csv, md, html, json) → use template path
+      - Path without extension → append .{default_format}
+      - Path with known extension → use as-is
+      - Path with unknown extension → use as-is
+    """
+    if output_arg is None:
+        return None
+
+    arg = output_arg.strip()
+
+    import os
+
+    if arg.lower() in KNOWN_FORMAT_NAMES:
+        ext = arg.lower()
+        resolved_dir = os.path.expanduser(output_dir) if output_dir else "."
+        filename = expand_filename_template(
+            filename_template,
+            author=author,
+            from_date=from_date,
+            to_date=to_date,
+            ext=ext,
+        )
+        return os.path.join(resolved_dir, filename)
+
+    _, ext = os.path.splitext(arg)
+    if not ext:
+        arg = f"{arg}.{default_format}"
+
+    return arg
+
+
+def save_period_to_config(
+    config_path: str,
+    from_str: str,
+    to_str: str,
+    precision: str,
+    dynamic: bool,
+) -> None:
+    """Save committed period to YAML config file.
+
+    Writes period.last_used.from / period.last_used.to.
+    When dynamic=False, also overwrites period.default_from / period.default_to.
+
+    Preserves all other sections unchanged. Creates config file if missing.
+    """
+    import yaml
+
+    path = Path(config_path)
+    raw: dict = {}
+    if path.exists():
+        with open(path, "r", encoding="utf-8") as fh:
+            raw = yaml.safe_load(fh) or {}
+
+    period = raw.setdefault("period", {})
+    period["last_used"] = {"from": from_str, "to": to_str}
+
+    if not dynamic:
+        period["default_from"] = from_str.split("T")[0] if "T" in from_str else from_str
+        period["default_to"] = to_str.split("T")[0] if "T" in to_str else to_str
+
+    ensure_config_dir(path.parent)
+    with open(path, "w", encoding="utf-8") as fh:
+        yaml.dump(raw, fh, allow_unicode=True, default_flow_style=False, sort_keys=False)
+    path.chmod(0o600)

tests/test_cli.py

@@ -18,9 +18,11 @@ def _reset_config_overrides():
 
     Config.set_redmine_url("")
     Config.set_redmine_api_key("")
+    Config._app = None
     yield
     Config.set_redmine_url("")
     Config.set_redmine_api_key("")
+    Config._app = None
 
 
 @pytest.mark.parametrize(
@@ -60,7 +62,7 @@ def test_cli_returns_zero_on_no_entries(mock_fetch):
 @mock.patch.dict(os.environ, {}, clear=True)
 def test_cli_config_error():
     """Невалидный конфиг -- выход 1."""
-    code = main(["--date", "2026-01-01--2026-01-31"])
+    code = main(["--date", "2026-01-01--2026-01-31", "--config-path", "/nonexistent/config.yml"])
     assert code == 1
 
 
@@ -95,13 +97,27 @@ def test_cli_unknown_output_extension(mock_fetch, tmp_path):
 
 @mock.patch.dict(os.environ, VALID_ENV, clear=True)
 @mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
-def test_cli_output_without_extension(mock_fetch, tmp_path):
+@mock.patch("redmine_reporter.cli.get_formatter_by_extension")
-    """Файл без расширения -- выход 1 с подсказкой."""
+def test_cli_output_without_extension(mock_get, mock_fetch, tmp_path):
+    """Файл без расширения — приложение расширяет default_format (#43)."""
     issue = _MockIssue()
     mock_fetch.return_value = [(issue, 1.0)]
+    mock_formatter = mock.MagicMock()
+    mock_get.return_value = mock_formatter
     output = str(tmp_path / "report")
-    code = main(["--date", "2026-01-01--2026-01-31", "--output", output])
+    code = main(
-    assert code == 1
+        [
+            "--date",
+            "2026-01-01--2026-01-31",
+            "--output",
+            output,
+            "--config-path",
+            str(tmp_path / "nonexistent.yml"),
+        ]
+    )
+    assert code == 0
+    saved_path = mock_formatter.save.call_args.args[1]
+    assert saved_path.endswith(".xlsx")
 
 
 @mock.patch.dict(os.environ, VALID_ENV, clear=True)
@@ -301,3 +317,451 @@ def test_cli_rejects_multiple_user_flags():
         ]
     )
     assert code == 1
+
+
+# ---------------------------------------------------------------------------
+# --init-config tests
+# ---------------------------------------------------------------------------
+
+
+class TestInitConfig:
+    """Tests for --init-config flag."""
+
+    @mock.patch.dict(os.environ, VALID_ENV, clear=True)
+    def test_init_config_creates_yaml_file(self, tmp_path):
+        """--init-config создаёт YAML файл с правильной структурой."""
+        import yaml
+
+        config_path = tmp_path / "config.yml"
+        code = main(["--init-config", "--config-path", str(config_path)])
+        assert code == 0
+        assert config_path.exists()
+
+        with open(config_path) as fh:
+            data = yaml.safe_load(fh)
+
+        assert "redmine" in data
+        assert data["redmine"]["url"] == "https://red.eltex.loc"
+        assert data["redmine"]["api_key"] == "${REDMINE_API_KEY}"
+
+    @mock.patch.dict(os.environ, VALID_ENV, clear=True)
+    def test_init_config_existing_file_no_force(self, tmp_path, capsys):
+        """Без --force существующий файл → предупреждение и выход 1."""
+        config_path = tmp_path / "config.yml"
+        config_path.write_text("existing: true")
+
+        code = main(["--init-config", "--config-path", str(config_path)])
+        assert code == 1
+        captured = capsys.readouterr()
+        assert "already exists" in captured.err or "already exists" in captured.out
+
+    @mock.patch.dict(os.environ, VALID_ENV, clear=True)
+    def test_init_config_force_overwrites(self, tmp_path):
+        """--init-config --force перезаписывает существующий файл."""
+        import yaml
+
+        config_path = tmp_path / "config.yml"
+        config_path.write_text("existing: true")
+
+        code = main(["--init-config", "--force", "--config-path", str(config_path)])
+        assert code == 0
+
+        with open(config_path) as fh:
+            data = yaml.safe_load(fh)
+
+        assert "redmine" in data
+        assert "existing" not in data
+
+    @mock.patch.dict(os.environ, VALID_ENV, clear=True)
+    def test_init_config_with_date_is_error(self, capsys):
+        """--init-config с --date → ошибка, взаимоисключающие."""
+        code = main(["--init-config", "--date", "2026-01-01--2026-01-31"])
+        assert code == 1
+
+    @mock.patch.dict(os.environ, VALID_ENV, clear=True)
+    def test_init_config_writes_secrets_as_env_ref(self, tmp_path):
+        """Секреты пишутся как ${VAR} когда переменная окружения существует."""
+        import yaml
+
+        config_path = tmp_path / "config.yml"
+        code = main(["--init-config", "--config-path", str(config_path)])
+        assert code == 0
+
+        with open(config_path) as fh:
+            data = yaml.safe_load(fh)
+
+        assert data["redmine"]["api_key"] == "${REDMINE_API_KEY}"
+
+    @mock.patch.dict(os.environ, {}, clear=True)
+    def test_init_config_no_env_vars(self, tmp_path):
+        """Без переменных окружения --init-config создаёт скелет."""
+        import yaml
+
+        config_path = tmp_path / "config.yml"
+        code = main(["--init-config", "--config-path", str(config_path)])
+        assert code == 0
+
+        with open(config_path) as fh:
+            data = yaml.safe_load(fh)
+
+        assert "redmine" in data
+        assert data["redmine"]["url"] == ""
+        assert data["redmine"]["api_key"] == ""
+
+
+@mock.patch.dict(os.environ, {}, clear=True)
+@mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
+def test_cli_autoloads_yaml_config(mock_fetch, tmp_path):
+    """CLI автоматически подгружает YAML-конфиг при запуске."""
+    config_path = tmp_path / "config.yml"
+    config_path.write_text(
+        "redmine:\n  url: https://yaml-redmine.example.com/\n  api_key: yaml-token\n"
+    )
+
+    mock_fetch.return_value = None
+    code = main(["--date", "2026-01-01--2026-01-31", "--config-path", str(config_path)])
+    assert code == 0
+
+
+# ---------------------------------------------------------------------------
+# #43: --output path resolution tests
+# ---------------------------------------------------------------------------
+
+
+class TestOutputPathResolution:
+    """Tests for --output flag with path defaults."""
+
+    @mock.patch.dict(os.environ, VALID_ENV, clear=True)
+    @mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
+    def test_bare_format_name_xlsx_uses_template_path(self, mock_fetch, tmp_path):
+        """--output xlsx без пути → использует шаблон из конфига."""
+        import yaml
+
+        config_path = tmp_path / "config.yml"
+        config_path.write_text(
+            yaml.dump(
+                {
+                    "output": {
+                        "dir": str(tmp_path / "reports"),
+                        "filename": "report_{date}.{ext}",
+                        "default_format": "xlsx",
+                    }
+                }
+            )
+        )
+
+        mock_fetch.return_value = None
+        code = main(
+            [
+                "--date",
+                "2026-01-01--2026-01-31",
+                "--output",
+                "xlsx",
+                "--config-path",
+                str(config_path),
+            ]
+        )
+        assert code == 0
+
+    @mock.patch.dict(os.environ, VALID_ENV, clear=True)
+    @mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
+    def test_output_without_extension_appends_default_format(self, mock_fetch, tmp_path):
+        """--output report без расширения → добавляет .xlsx."""
+        issue = _MockIssue()
+        mock_fetch.return_value = [(issue, 1.0)]
+
+        output = str(tmp_path / "report")
+        with mock.patch("redmine_reporter.cli.get_formatter_by_extension") as mock_get:
+            mock_formatter = mock.MagicMock()
+            mock_get.return_value = mock_formatter
+            code = main(
+                [
+                    "--date",
+                    "2026-01-01--2026-01-31",
+                    "--output",
+                    output,
+                    "--config-path",
+                    str(tmp_path / "nonexistent.yml"),
+                ]
+            )
+            assert code == 0
+            mock_formatter.save.assert_called_once()
+            saved_path = mock_formatter.save.call_args.args[1]
+            assert saved_path.endswith(".xlsx")
+
+    @mock.patch.dict(os.environ, VALID_ENV, clear=True)
+    @mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
+    def test_output_with_known_extension_unchanged(self, mock_fetch, tmp_path):
+        """--output report.csv с явным расширением передаётся как есть."""
+        issue = _MockIssue()
+        mock_fetch.return_value = [(issue, 1.0)]
+
+        with mock.patch("redmine_reporter.cli.get_formatter_by_extension") as mock_get:
+            mock_formatter = mock.MagicMock()
+            mock_get.return_value = mock_formatter
+            code = main(
+                [
+                    "--date",
+                    "2026-01-01--2026-01-31",
+                    "--output",
+                    str(tmp_path / "report.csv"),
+                    "--config-path",
+                    str(tmp_path / "nonexistent.yml"),
+                ]
+            )
+            assert code == 0
+            mock_formatter.save.assert_called_once()
+            saved_path = mock_formatter.save.call_args.args[1]
+            assert saved_path.endswith(".csv")
+
+    @mock.patch.dict(os.environ, VALID_ENV, clear=True)
+    @mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
+    def test_output_bare_format_invalid_is_treated_as_path(self, mock_fetch, tmp_path):
+        """--output notanxlsx (no path, not known format) → treated as path + .xlsx appended."""
+        issue = _MockIssue()
+        mock_fetch.return_value = [(issue, 1.0)]
+
+        with mock.patch("redmine_reporter.cli.get_formatter_by_extension") as mock_get:
+            mock_formatter = mock.MagicMock()
+            mock_get.return_value = mock_formatter
+            code = main(
+                [
+                    "--date",
+                    "2026-01-01--2026-01-31",
+                    "--output",
+                    "myreport",
+                    "--config-path",
+                    str(tmp_path / "nonexistent.yml"),
+                ]
+            )
+            assert code == 0
+            mock_formatter.save.assert_called_once()
+            saved_path = mock_formatter.save.call_args.args[1]
+            assert saved_path == "myreport.xlsx"
+
+
+# ---------------------------------------------------------------------------
+# #44: --commit tests
+# ---------------------------------------------------------------------------
+
+
+class TestCommitFlag:
+    """Tests for --commit flag."""
+
+    @mock.patch.dict(os.environ, VALID_ENV, clear=True)
+    @mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
+    @mock.patch("redmine_reporter.cli.save_period_to_config")
+    def test_commit_saves_period_to_config(self, mock_save, mock_fetch, tmp_path):
+        """--commit сохраняет период в YAML-конфиг."""
+        import yaml
+
+        issue = _MockIssue()
+        mock_fetch.return_value = [(issue, 1.0)]
+
+        config_path = tmp_path / "config.yml"
+        config_path.write_text(yaml.dump({"period": {"precision": "date", "dynamic": True}}))
+
+        with mock.patch("redmine_reporter.cli.get_formatter_by_extension") as mock_get:
+            mock_formatter = mock.MagicMock()
+            mock_get.return_value = mock_formatter
+            code = main(
+                [
+                    "--date",
+                    "2026-06-01--2026-06-30",
+                    "--commit",
+                    "--output",
+                    str(tmp_path / "report.xlsx"),
+                    "--config-path",
+                    str(config_path),
+                ]
+            )
+            assert code == 0
+
+        mock_save.assert_called_once_with(
+            str(config_path), "2026-06-01", "2026-06-30", "date", True
+        )
+
+    @mock.patch.dict(os.environ, VALID_ENV, clear=True)
+    @mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
+    @mock.patch("redmine_reporter.cli.save_period_to_config")
+    def test_commit_with_precision_datetime_passes_datetime_strings(
+        self, mock_save, mock_fetch, tmp_path
+    ):
+        """При precision=datetime --commit сохраняет timestamps."""
+        import yaml
+
+        issue = _MockIssue()
+        mock_fetch.return_value = [(issue, 1.0)]
+
+        config_path = tmp_path / "config.yml"
+        config_path.write_text(yaml.dump({"period": {"precision": "datetime", "dynamic": True}}))
+
+        with mock.patch("redmine_reporter.cli.get_formatter_by_extension") as mock_get:
+            mock_formatter = mock.MagicMock()
+            mock_get.return_value = mock_formatter
+            code = main(
+                [
+                    "--date",
+                    "2026-06-30--2026-06-30",
+                    "--commit",
+                    "--output",
+                    str(tmp_path / "report.xlsx"),
+                    "--config-path",
+                    str(config_path),
+                ]
+            )
+            assert code == 0
+
+        call_args = mock_save.call_args
+        assert call_args is not None
+        saved_from, saved_to = call_args.args[1], call_args.args[2]
+        assert "T" in saved_from
+        assert "T" in saved_to
+
+    @mock.patch.dict(os.environ, VALID_ENV, clear=True)
+    @mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
+    def test_commit_no_entries_does_not_save(self, mock_fetch, tmp_path):
+        """Без записей --commit не пишет конфиг."""
+        mock_fetch.return_value = None
+
+        config_path = tmp_path / "config.yml"
+        config_path.write_text("period:\n  precision: date\n  dynamic: true\n")
+
+        code = main(
+            [
+                "--date",
+                "2026-01-01--2026-01-31",
+                "--commit",
+                "--config-path",
+                str(config_path),
+            ]
+        )
+        assert code == 0
+
+    @mock.patch.dict(os.environ, VALID_ENV, clear=True)
+    @mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
+    @mock.patch("redmine_reporter.cli.save_period_to_config")
+    def test_commit_dynamic_false_overwrites_defaults(self, mock_save, mock_fetch, tmp_path):
+        """При dynamic=false --commit перезаписывает default_from/to."""
+        import yaml
+
+        issue = _MockIssue()
+        mock_fetch.return_value = [(issue, 1.0)]
+
+        config_path = tmp_path / "config.yml"
+        config_path.write_text(yaml.dump({"period": {"precision": "date", "dynamic": False}}))
+
+        with mock.patch("redmine_reporter.cli.get_formatter_by_extension") as mock_get:
+            mock_formatter = mock.MagicMock()
+            mock_get.return_value = mock_formatter
+            code = main(
+                [
+                    "--date",
+                    "2026-06-01--2026-06-30",
+                    "--commit",
+                    "--output",
+                    str(tmp_path / "report.xlsx"),
+                    "--config-path",
+                    str(config_path),
+                ]
+            )
+            assert code == 0
+
+        mock_save.assert_called_once_with(
+            str(config_path), "2026-06-01", "2026-06-30", "date", False
+        )
+
+    @mock.patch.dict(os.environ, VALID_ENV, clear=True)
+    @mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
+    @mock.patch("redmine_reporter.cli.save_period_to_config")
+    def test_commit_without_output_uses_default_path(self, mock_save, mock_fetch, tmp_path):
+        """--commit без --output сохраняет файл по шаблону из конфига."""
+        import yaml
+
+        issue = _MockIssue()
+        mock_fetch.return_value = [(issue, 1.0)]
+
+        config_path = tmp_path / "config.yml"
+        config_path.write_text(
+            yaml.dump(
+                {
+                    "period": {"precision": "date", "dynamic": True},
+                    "output": {
+                        "dir": str(tmp_path / "reports"),
+                        "filename": "report_{date}.{ext}",
+                        "default_format": "xlsx",
+                    },
+                }
+            )
+        )
+
+        with mock.patch("redmine_reporter.cli.get_formatter_by_extension") as mock_get:
+            mock_formatter = mock.MagicMock()
+            mock_get.return_value = mock_formatter
+            code = main(
+                [
+                    "--date",
+                    "2026-06-01--2026-06-30",
+                    "--commit",
+                    "--config-path",
+                    str(config_path),
+                ]
+            )
+            assert code == 0
+            mock_formatter.save.assert_called_once()
+
+    @mock.patch.dict(os.environ, VALID_ENV, clear=True)
+    @mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
+    @mock.patch("redmine_reporter.cli.save_period_to_config")
+    def test_commit_prints_info_to_stderr(self, mock_save, mock_fetch, capsys, tmp_path):
+        """--commit выводит сообщение о фиксации в stderr."""
+        import yaml
+
+        issue = _MockIssue()
+        mock_fetch.return_value = [(issue, 1.0)]
+
+        config_path = tmp_path / "config.yml"
+        config_path.write_text(yaml.dump({"period": {"precision": "date", "dynamic": True}}))
+
+        with mock.patch("redmine_reporter.cli.get_formatter_by_extension") as mock_get:
+            mock_formatter = mock.MagicMock()
+            mock_get.return_value = mock_formatter
+            code = main(
+                [
+                    "--date",
+                    "2026-06-01--2026-06-30",
+                    "--commit",
+                    "--output",
+                    str(tmp_path / "report.xlsx"),
+                    "--config-path",
+                    str(config_path),
+                ]
+            )
+            assert code == 0
+
+        captured = capsys.readouterr()
+        assert "commit" in captured.err.lower() or "Commit" in captured.err
+
+    @mock.patch.dict(os.environ, VALID_ENV, clear=True)
+    @mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
+    @mock.patch("redmine_reporter.cli.save_period_to_config")
+    def test_commit_empty_issues_no_save(self, mock_save, mock_fetch, tmp_path):
+        """Пустой список задач — --commit не сохраняет конфиг."""
+        import yaml
+
+        mock_fetch.return_value = []
+
+        config_path = tmp_path / "config.yml"
+        config_path.write_text(yaml.dump({"period": {"precision": "date", "dynamic": True}}))
+
+        code = main(
+            [
+                "--date",
+                "2026-01-01--2026-01-31",
+                "--commit",
+                "--config-path",
+                str(config_path),
+            ]
+        )
+        assert code == 0
+        mock_save.assert_not_called()

tests/test_client.py

@@ -45,7 +45,7 @@ def test_fetch_aggregates_hours_per_issue(mock_redmine_class):
 
     assert result is not None
     assert len(result) == 1
-    issue, total_hours = result[0]
+    issue, total_hours, _activities = result[0]
     assert total_hours == 3.5
 
 
@@ -109,7 +109,7 @@ def test_fetch_multiple_issues(mock_redmine_class):
     assert result is not None
     assert len(result) == 2
 
-    hours_by_id = {issue.id: hours for issue, hours in result}
+    hours_by_id = {issue.id: hours for issue, hours, _ in result}
     assert hours_by_id[1] == 1.5
     assert hours_by_id[2] == 2.0
 
@@ -435,3 +435,239 @@ def test_fetch_chunks_large_issue_count(mock_redmine_class):
     assert len(call_chunks[2].split(",")) == 50
     assert result is not None
     assert len(result) == 250
+
+
+# -- #47: Дедупликация time entries по datetime --
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_dedup_filters_entries_created_before_cutoff(mock_redmine_class):
+    """Записи с created_on/updated_on раньше dedup_before исключаются."""
+    from datetime import datetime, timezone
+
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine, user_id=123)
+
+    dedup_cutoff = datetime(2026, 7, 1, 12, 0, 0, tzinfo=timezone.utc)
+
+    e1 = mock.MagicMock()
+    e1.issue.id = 1
+    e1.hours = 2.0
+    e1.created_on = datetime(2026, 7, 1, 10, 0, 0, tzinfo=timezone.utc)
+    e1.updated_on = datetime(2026, 7, 1, 10, 0, 0, tzinfo=timezone.utc)
+
+    e2 = mock.MagicMock()
+    e2.issue.id = 2
+    e2.hours = 1.0
+    e2.created_on = datetime(2026, 7, 1, 14, 0, 0, tzinfo=timezone.utc)
+    e2.updated_on = datetime(2026, 7, 1, 14, 0, 0, tzinfo=timezone.utc)
+
+    mock_redmine.time_entry.filter.return_value = [e1, e2]
+
+    mock_issue1 = mock.MagicMock()
+    mock_issue1.id = 1
+    mock_issue1.project = "P"
+    mock_issue2 = mock.MagicMock()
+    mock_issue2.id = 2
+    mock_issue2.project = "P"
+    mock_redmine.issue.filter.return_value = [mock_issue1, mock_issue2]
+
+    result = fetch_issues_with_spent_time("2026-07-01", "2026-07-01", dedup_before=dedup_cutoff)
+
+    assert result is not None
+    assert len(result) == 1
+    assert result[0][0].id == 2
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_dedup_filters_entries_with_old_created_even_if_updated_recently(mock_redmine_class):
+    """Записи с created_on < cutoff исключаются даже при updated_on >= cutoff (AND-логика)."""
+    from datetime import datetime, timezone
+
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine, user_id=123)
+
+    dedup_cutoff = datetime(2026, 7, 1, 12, 0, 0, tzinfo=timezone.utc)
+
+    e1 = mock.MagicMock()
+    e1.issue.id = 1
+    e1.hours = 2.0
+    e1.created_on = datetime(2026, 7, 1, 10, 0, 0, tzinfo=timezone.utc)
+    e1.updated_on = datetime(2026, 7, 1, 15, 0, 0, tzinfo=timezone.utc)
+
+    mock_redmine.time_entry.filter.return_value = [e1]
+    mock_redmine.issue.filter.return_value = []
+
+    result = fetch_issues_with_spent_time("2026-07-01", "2026-07-01", dedup_before=dedup_cutoff)
+
+    assert result is None
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_dedup_keeps_entries_created_after_cutoff(mock_redmine_class):
+    """Записи с created_on/updated_on >= dedup_before сохраняются."""
+    from datetime import datetime, timezone
+
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine, user_id=123)
+
+    dedup_cutoff = datetime(2026, 7, 1, 12, 0, 0, tzinfo=timezone.utc)
+
+    e1 = mock.MagicMock()
+    e1.issue.id = 1
+    e1.hours = 2.0
+    e1.created_on = datetime(2026, 7, 1, 12, 0, 0, tzinfo=timezone.utc)
+    e1.updated_on = datetime(2026, 7, 1, 12, 0, 0, tzinfo=timezone.utc)
+
+    mock_redmine.time_entry.filter.return_value = [e1]
+
+    mock_issue1 = mock.MagicMock()
+    mock_issue1.id = 1
+    mock_issue1.project = "P"
+    mock_issue1.subject = "T"
+    mock_issue1.status = "New"
+    mock_redmine.issue.filter.return_value = [mock_issue1]
+
+    result = fetch_issues_with_spent_time("2026-07-01", "2026-07-01", dedup_before=dedup_cutoff)
+
+    assert result is not None
+    assert len(result) == 1
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_dedup_entries_without_created_on_are_kept(mock_redmine_class):
+    """Записи без created_on/updated_on не фильтруются (сохраняются)."""
+    from datetime import datetime, timezone
+
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine, user_id=123)
+
+    dedup_cutoff = datetime(2026, 7, 1, 12, 0, 0, tzinfo=timezone.utc)
+
+    e1 = mock.MagicMock()
+    e1.issue.id = 1
+    e1.hours = 2.0
+    e1.created_on = None
+    e1.updated_on = None
+
+    mock_redmine.time_entry.filter.return_value = [e1]
+
+    mock_issue1 = mock.MagicMock()
+    mock_issue1.id = 1
+    mock_issue1.project = "P"
+    mock_issue1.subject = "T"
+    mock_issue1.status = "New"
+    mock_redmine.issue.filter.return_value = [mock_issue1]
+
+    result = fetch_issues_with_spent_time("2026-07-01", "2026-07-01", dedup_before=dedup_cutoff)
+
+    assert result is not None
+    assert len(result) == 1
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_dedup_handles_string_created_on(mock_redmine_class):
+    """created_on может быть строкой ISO — парсим корректно."""
+    from datetime import datetime, timezone
+
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine, user_id=123)
+
+    dedup_cutoff = datetime(2026, 7, 1, 12, 0, 0, tzinfo=timezone.utc)
+
+    e1 = mock.MagicMock()
+    e1.issue.id = 1
+    e1.hours = 2.0
+    e1.created_on = "2026-07-01T10:00:00Z"
+    e1.updated_on = "2026-07-01T10:00:00Z"
+
+    mock_redmine.time_entry.filter.return_value = [e1]
+    mock_redmine.issue.filter.return_value = []
+
+    result = fetch_issues_with_spent_time("2026-07-01", "2026-07-01", dedup_before=dedup_cutoff)
+
+    assert result is None
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_no_dedup_when_cutoff_is_none(mock_redmine_class):
+    """Без dedup_before фильтрация не применяется."""
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine, user_id=123)
+
+    e1 = mock.MagicMock()
+    e1.issue.id = 1
+    e1.hours = 2.0
+    e1.created_on = None
+    e1.updated_on = None
+
+    mock_redmine.time_entry.filter.return_value = [e1]
+
+    mock_issue1 = mock.MagicMock()
+    mock_issue1.id = 1
+    mock_issue1.project = "P"
+    mock_issue1.subject = "T"
+    mock_issue1.status = "New"
+    mock_redmine.issue.filter.return_value = [mock_issue1]
+
+    result = fetch_issues_with_spent_time("2026-07-01", "2026-07-01", dedup_before=None)
+
+    assert result is not None
+    assert len(result) == 1
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_dedup_mixed_entries_correct_filtering(mock_redmine_class):
+    """Смешанные записи: старые исключаются, новые сохраняются, аки идут."""
+    from datetime import datetime, timezone
+
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine, user_id=123)
+
+    dedup_cutoff = datetime(2026, 7, 1, 12, 0, 0, tzinfo=timezone.utc)
+
+    e_old = mock.MagicMock()
+    e_old.issue.id = 10
+    e_old.hours = 1.0
+    e_old.created_on = datetime(2026, 7, 1, 9, 0, 0, tzinfo=timezone.utc)
+    e_old.updated_on = datetime(2026, 7, 1, 9, 0, 0, tzinfo=timezone.utc)
+
+    e_new = mock.MagicMock()
+    e_new.issue.id = 20
+    e_new.hours = 3.0
+    e_new.created_on = datetime(2026, 7, 1, 14, 0, 0, tzinfo=timezone.utc)
+    e_new.updated_on = datetime(2026, 7, 1, 14, 0, 0, tzinfo=timezone.utc)
+
+    e_akiy = mock.MagicMock()
+    e_akiy.issue.id = 30
+    e_akiy.hours = 5.0
+    e_akiy.created_on = None
+    e_akiy.updated_on = None
+
+    mock_redmine.time_entry.filter.return_value = [e_old, e_new, e_akiy]
+
+    mock_issue_new = mock.MagicMock()
+    mock_issue_new.id = 20
+    mock_issue_new.project = "P"
+    mock_issue_new.subject = "T"
+    mock_issue_new.status = "New"
+    mock_issue_akiy = mock.MagicMock()
+    mock_issue_akiy.id = 30
+    mock_issue_akiy.project = "P"
+    mock_issue_akiy.subject = "T2"
+    mock_issue_akiy.status = "New"
+    mock_redmine.issue.filter.return_value = [mock_issue_new, mock_issue_akiy]
+
+    result = fetch_issues_with_spent_time("2026-07-01", "2026-07-01", dedup_before=dedup_cutoff)
+
+    assert result is not None
+    assert len(result) == 2
+    ids = {r[0].id for r in result}
+    assert ids == {20, 30}

tests/test_config.py

@@ -1,9 +1,11 @@
 import os
+import tempfile
+from pathlib import Path
 from unittest import mock
 
 import pytest
 
-from redmine_reporter.config import DEFAULT_REDMINE_VERIFY, Config
+from redmine_reporter.config import DEFAULT_REDMINE_VERIFY, AppConfig, Config
 
 
 @mock.patch.dict(
@@ -133,3 +135,425 @@ def test_env_var_takes_priority_over_dotenv(mock_load):
 def test_get_redmine_password_strips_whitespace():
     """Пароль обрезается от whitespace, как и все остальные геттеры."""
     assert Config.get_redmine_password() == "secret123"
+
+
+# ---------------------------------------------------------------------------
+# AppConfig tests — YAML config loading
+# ---------------------------------------------------------------------------
+
+
+FULL_YAML = """\
+redmine:
+  url: https://redmine.example.com/
+  api_key: ${MISSING_API_KEY_FOR_TEST}
+  author: "Тестовый Автор"
+  verify_ssl: false
+
+period:
+  precision: datetime
+  default_from: "2026-06-01"
+  default_to: "2026-06-30"
+  dynamic: true
+  last_used:
+    from: "2026-06-30T09:00:00"
+    to: "2026-06-30T12:00:00"
+
+output:
+  dir: ~/reports
+  filename: "{author}_{from}_{to}.{ext}"
+  default_format: xlsx
+
+email:
+  smtp:
+    host: smtp.example.com
+    port: 587
+    user: bot@example.com
+    password: ${MISSING_SMTP_PASSWORD_FOR_TEST}
+    tls: true
+  from: bot@example.com
+  to:
+    - boss@example.com
+  cc: []
+  bcc: []
+  subject: "Отчёт {author} за {period}"
+  body_text: "Во вложении отчёт."
+  attach: true
+"""
+
+
+class TestAppConfigFromYaml:
+    """Tests for AppConfig.from_yaml()."""
+
+    def test_loads_all_sections_from_valid_yaml(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text(FULL_YAML)
+
+            cfg = AppConfig.from_yaml(yaml_path)
+
+            assert cfg.redmine_url == "https://redmine.example.com/"
+            assert cfg.redmine_api_key == ""  # ${MISSING_API_KEY_FOR_TEST} not set
+            assert cfg.redmine_author == "Тестовый Автор"
+            assert cfg.redmine_verify is False
+            assert cfg.period_precision == "datetime"
+            assert cfg.period_default_from == "2026-06-01"
+            assert cfg.period_default_to == "2026-06-30"
+            assert cfg.period_dynamic is True
+            assert cfg.period_last_used_from == "2026-06-30T09:00:00"
+            assert cfg.period_last_used_to == "2026-06-30T12:00:00"
+            assert cfg.output_dir == "~/reports"
+            assert cfg.output_filename == "{author}_{from}_{to}.{ext}"
+            assert cfg.output_default_format == "xlsx"
+            assert cfg.email.smtp.host == "smtp.example.com"
+            assert cfg.email.smtp.port == 587
+            assert cfg.email.smtp.user == "bot@example.com"
+            assert cfg.email.smtp.password == ""
+            assert cfg.email.smtp.tls is True
+            assert cfg.email.from_ == "bot@example.com"
+            assert cfg.email.to == ["boss@example.com"]
+            assert cfg.email.subject == "Отчёт {author} за {period}"
+
+    def test_partial_yaml_uses_defaults_for_missing(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text("redmine:\n  url: https://x.com/\n")
+
+            cfg = AppConfig.from_yaml(yaml_path)
+
+            assert cfg.redmine_url == "https://x.com/"
+            # defaults for everything else
+            assert cfg.redmine_author == ""
+            assert cfg.period_precision == "date"
+            assert cfg.output_dir == ""
+            assert cfg.email.to == []
+
+    def test_empty_file_returns_all_defaults(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text("")
+
+            cfg = AppConfig.from_yaml(yaml_path)
+
+            assert cfg.redmine_url == ""
+            assert cfg.redmine_api_key == ""
+            assert cfg.period_precision == "date"
+
+    def test_file_not_found_returns_all_defaults(self):
+        cfg = AppConfig.from_yaml("/nonexistent/path/config.yml")
+        assert cfg.redmine_url == ""
+
+    @mock.patch.dict(os.environ, {"REDMINE_API_KEY": "secret-token"}, clear=True)
+    def test_env_var_resolved_in_yaml(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text("redmine:\n  api_key: ${REDMINE_API_KEY}\n")
+
+            cfg = AppConfig.from_yaml(yaml_path)
+
+            assert cfg.redmine_api_key == "secret-token"
+
+    def test_verify_ssl_true_returns_default_ca_path(self):
+        """verify_ssl: true → DEFAULT_REDMINE_VERIFY (путь), не Python True."""
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text("redmine:\n  verify_ssl: true\n")
+
+            cfg = AppConfig.from_yaml(yaml_path)
+
+            assert cfg.redmine_verify == DEFAULT_REDMINE_VERIFY
+            assert cfg.redmine_verify is not True  # не бул!
+
+    def test_verify_ssl_false_returns_false(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text("redmine:\n  verify_ssl: false\n")
+
+            cfg = AppConfig.from_yaml(yaml_path)
+
+            assert cfg.redmine_verify is False
+
+    def test_missing_env_var_logs_warning(self, caplog):
+        import logging
+
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text("redmine:\n  api_key: ${MISSING_KEY}\n")
+
+            with caplog.at_level(logging.WARNING):
+                cfg = AppConfig.from_yaml(yaml_path)
+
+            assert cfg.redmine_api_key == ""
+            assert "MISSING_KEY" in caplog.text
+
+    def test_unknown_top_level_key_logs_warning(self, caplog):
+        import logging
+
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text("unknown_section:\n  foo: bar\n")
+
+            with caplog.at_level(logging.WARNING):
+                AppConfig.from_yaml(yaml_path)
+
+            assert "unknown_section" in caplog.text
+
+
+# ---------------------------------------------------------------------------
+# Config priority chain tests — YAML fallback
+# ---------------------------------------------------------------------------
+
+
+class TestConfigYamlFallback:
+    """Tests that Config.get_*() falls back to YAML when env/CLI not set."""
+
+    @mock.patch.dict(os.environ, {}, clear=True)
+    def test_url_from_yaml_when_no_env_or_cli(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text("redmine:\n  url: https://yaml-redmine.example.com/\n")
+
+            Config._cli_url = None
+            Config._app = AppConfig.from_yaml(yaml_path)
+
+            assert Config.get_redmine_url() == "https://yaml-redmine.example.com"
+
+    @mock.patch.dict(os.environ, {}, clear=True)
+    def test_cli_beats_yaml(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text("redmine:\n  url: https://yaml-redmine.example.com/\n")
+
+            Config._app = AppConfig.from_yaml(yaml_path)
+            Config.set_redmine_url("https://cli-override.example.com")
+
+            assert Config.get_redmine_url() == "https://cli-override.example.com"
+
+    @mock.patch.dict(os.environ, {"REDMINE_URL": "https://env-redmine.example.com/"}, clear=True)
+    def test_env_beats_yaml(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text("redmine:\n  url: https://yaml-redmine.example.com/\n")
+
+            Config._cli_url = None
+            Config._app = AppConfig.from_yaml(yaml_path)
+
+            assert Config.get_redmine_url() == "https://env-redmine.example.com"
+
+    @mock.patch.dict(os.environ, {}, clear=True)
+    def test_date_range_from_yaml(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text(
+                "period:\n  default_from: '2026-03-01'\n  default_to: '2026-03-15'\n"
+            )
+
+            Config._app = AppConfig.from_yaml(yaml_path)
+
+            assert Config.get_default_date_range() == "2026-03-01--2026-03-15"
+
+    @mock.patch.dict(os.environ, {}, clear=True)
+    def test_author_from_yaml(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text("redmine:\n  author: 'Автор Из Ямла'\n")
+
+            Config._app = AppConfig.from_yaml(yaml_path)
+
+            assert Config.get_author("") == "Автор Из Ямла"
+
+    @mock.patch.dict(os.environ, {}, clear=True)
+    def test_validate_passes_with_yaml_url_and_api_key(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text(
+                "redmine:\n  url: https://yaml.example.com/\n  api_key: yaml-token\n"
+            )
+
+            Config._cli_url = None
+            Config._cli_api_key = None
+            Config._app = AppConfig.from_yaml(yaml_path)
+
+            # Не должно быть исключения
+            Config.validate()
+
+    @mock.patch.dict(os.environ, {}, clear=True)
+    def test_default_date_range_env_beats_yaml(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text(
+                "period:\n  default_from: '2026-03-01'\n  default_to: '2026-03-15'\n"
+            )
+
+            Config._app = AppConfig.from_yaml(yaml_path)
+
+        with mock.patch.dict(
+            os.environ,
+            {"DEFAULT_FROM_DATE": "2026-07-01", "DEFAULT_TO_DATE": "2026-07-15"},
+            clear=True,
+        ):
+            assert Config.get_default_date_range() == "2026-07-01--2026-07-15"
+
+
+class TestConfigPeriodPrecision:
+    """Tests for period.precision and period.last_used."""
+
+    @mock.patch.dict(os.environ, {}, clear=True)
+    def test_get_period_precision_defaults_to_date(self):
+        """Без YAML-конфига precision == 'date'."""
+        Config._app = None
+        assert Config.get_period_precision() == "date"
+
+    @mock.patch.dict(os.environ, {}, clear=True)
+    def test_get_period_precision_from_yaml(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text("period:\n  precision: datetime\n")
+
+            Config._app = AppConfig.from_yaml(yaml_path)
+            assert Config.get_period_precision() == "datetime"
+
+    @mock.patch.dict(os.environ, {}, clear=True)
+    def test_get_last_used_from_yaml(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text(
+                "period:\n  last_used:\n    from: '2026-06-30T09:00:00'\n    to: '2026-06-30T12:00:00'\n"
+            )
+
+            Config._app = AppConfig.from_yaml(yaml_path)
+            assert Config.get_last_used_from() == "2026-06-30T09:00:00"
+            assert Config.get_last_used_to() == "2026-06-30T12:00:00"
+
+    @mock.patch.dict(os.environ, {}, clear=True)
+    def test_get_last_used_returns_empty_when_not_set(self):
+        Config._app = AppConfig()
+        assert Config.get_last_used_from() == ""
+        assert Config.get_last_used_to() == ""
+
+    @mock.patch.dict(os.environ, {}, clear=True)
+    def test_yaml_loads_last_used_field(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text(
+                "period:\n  last_used:\n    from: '2026-07-01T08:00:00'\n    to: '2026-07-01T18:00:00'\n"
+            )
+
+            cfg = AppConfig.from_yaml(yaml_path)
+            assert cfg.period_last_used_from == "2026-07-01T08:00:00"
+            assert cfg.period_last_used_to == "2026-07-01T18:00:00"
+
+    @mock.patch.dict(os.environ, {}, clear=True)
+    def test_yaml_without_last_used_has_empty_fields(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text("period:\n  precision: date\n")
+
+            cfg = AppConfig.from_yaml(yaml_path)
+            assert cfg.period_last_used_from == ""
+            assert cfg.period_last_used_to == ""
+
+
+class TestComputeNextPeriod:
+    """Tests for compute_next_period()."""
+
+    def test_full_month_goes_to_next_full_month(self):
+        from redmine_reporter.config import compute_next_period
+
+        nf, nt = compute_next_period("2026-06-01", "2026-06-30", "date")
+        assert nf == "2026-07-01"
+        assert nt == "2026-07-31"
+
+    def test_december_to_next_year_january(self):
+        from redmine_reporter.config import compute_next_period
+
+        nf, nt = compute_next_period("2025-12-01", "2025-12-31", "date")
+        assert nf == "2026-01-01"
+        assert nt == "2026-01-31"
+
+    def test_february_2026_non_leap_to_march(self):
+        from redmine_reporter.config import compute_next_period
+
+        nf, nt = compute_next_period("2026-02-01", "2026-02-28", "date")
+        assert nf == "2026-03-01"
+        assert nt == "2026-03-31"
+
+    def test_arbitrary_range_same_length_from_to_plus_one(self):
+        from redmine_reporter.config import compute_next_period
+
+        nf, nt = compute_next_period("2026-06-15", "2026-06-20", "date")
+        assert nf == "2026-06-21"
+        assert nt == "2026-06-26"
+
+    def test_single_day_range_moves_one_day(self):
+        from redmine_reporter.config import compute_next_period
+
+        nf, nt = compute_next_period("2026-06-15", "2026-06-15", "date")
+        assert nf == "2026-06-16"
+        assert nt == "2026-06-16"
+
+    def test_cross_month_range(self):
+        from redmine_reporter.config import compute_next_period
+
+        nf, nt = compute_next_period("2026-06-25", "2026-07-05", "date")
+        assert nf == "2026-07-06"
+        assert nt == "2026-07-16"
+
+    def test_datetime_precision_moves_by_seconds(self):
+        from redmine_reporter.config import compute_next_period
+
+        nf, nt = compute_next_period("2026-06-30T09:00:00", "2026-06-30T12:00:00", "datetime")
+        assert nf == "2026-06-30T12:00:01"
+        assert nt == "2026-06-30T15:00:01"
+
+
+class TestDefaultDateRangeWithLastUsed:
+    """Tests that get_default_date_range() uses last_used when dynamic=True."""
+
+    @mock.patch.dict(os.environ, {}, clear=True)
+    def test_uses_last_used_when_dynamic_true(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text(
+                "period:\n"
+                "  precision: date\n"
+                "  dynamic: true\n"
+                "  last_used:\n"
+                "    from: '2026-05-01'\n"
+                "    to: '2026-05-31'\n"
+            )
+            Config._app = AppConfig.from_yaml(yaml_path)
+            result = Config.get_default_date_range()
+            assert result == "2026-06-01--2026-06-30"
+
+    @mock.patch.dict(os.environ, {}, clear=True)
+    def test_ignores_last_used_when_dynamic_false(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text(
+                "period:\n"
+                "  precision: date\n"
+                "  dynamic: false\n"
+                "  default_from: '2026-03-01'\n"
+                "  default_to: '2026-03-15'\n"
+                "  last_used:\n"
+                "    from: '2026-06-01'\n"
+                "    to: '2026-06-30'\n"
+            )
+            Config._app = AppConfig.from_yaml(yaml_path)
+            result = Config.get_default_date_range()
+            assert result == "2026-03-01--2026-03-15"
+
+    @mock.patch.dict(os.environ, {}, clear=True)
+    def test_falls_back_when_no_last_used_even_with_dynamic(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text(
+                "period:\n"
+                "  precision: date\n"
+                "  dynamic: true\n"
+                "  default_from: '2026-04-01'\n"
+                "  default_to: '2026-04-15'\n"
+            )
+            Config._app = AppConfig.from_yaml(yaml_path)
+            result = Config.get_default_date_range()
+            assert result == "2026-04-01--2026-04-15"

tests/test_yaml_config.py

@@ -0,0 +1,320 @@
+import logging
+import os
+import tempfile
+from pathlib import Path
+from unittest import mock
+
+from redmine_reporter.yaml_config import (
+    check_file_permissions,
+    ensure_config_dir,
+    expand_filename_template,
+    resolve_env_vars,
+)
+
+
+class TestResolveEnvVars:
+    """Tests for ${VAR} resolution."""
+
+    @mock.patch.dict(os.environ, {"MY_VAR": "hello"}, clear=True)
+    def test_replaces_var_with_env_value(self):
+        assert resolve_env_vars("prefix_${MY_VAR}_suffix") == "prefix_hello_suffix"
+
+    @mock.patch.dict(os.environ, {}, clear=True)
+    def test_missing_var_returns_empty_and_warns(self, caplog):
+        with caplog.at_level(logging.WARNING):
+            result = resolve_env_vars("${MISSING_VAR}")
+        assert result == ""
+        assert "MISSING_VAR" in caplog.text
+
+    def test_no_braces_returns_unchanged(self):
+        assert resolve_env_vars("plain text no vars") == "plain text no vars"
+
+    @mock.patch.dict(os.environ, {"A": "${B}", "B": "final"}, clear=True)
+    def test_non_recursive_no_double_resolution(self):
+        # A → literal "${B}", B → "final". Non-recursive means we get "${B}", not "final".
+        result = resolve_env_vars("${A}")
+        assert result == "${B}"
+
+
+class TestEnsureConfigDir:
+    """Tests for config directory creation."""
+
+    def test_creates_dir_with_0700(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            config_dir = Path(tmp) / "test_config"
+            result = ensure_config_dir(config_dir)
+            assert result == config_dir
+            assert result.exists()
+            assert result.is_dir()
+            mode = result.stat().st_mode & 0o777
+            assert mode == 0o700
+
+    def test_noop_if_dir_exists(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            config_dir = Path(tmp) / "existing"
+            config_dir.mkdir(mode=0o700)
+            mtime_before = config_dir.stat().st_mtime
+            result = ensure_config_dir(config_dir)
+            assert result == config_dir
+            assert config_dir.stat().st_mtime == mtime_before
+
+
+class TestCheckFilePermissions:
+    """Tests for config file permission checks."""
+
+    def test_warns_on_permissive_file(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            f = Path(tmp) / "open.yml"
+            f.write_text("key: value")
+            f.chmod(0o644)
+            warnings = check_file_permissions(f)
+            assert len(warnings) >= 1
+            assert "0644" in warnings[0] or "permissions" in warnings[0].lower()
+
+    def test_silent_on_0600(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            f = Path(tmp) / "secure.yml"
+            f.write_text("key: value")
+            f.chmod(0o600)
+            warnings = check_file_permissions(f)
+            assert warnings == []
+
+
+class TestExpandFilenameTemplate:
+    """Tests for filename template expansion."""
+
+    def test_expands_all_placeholders(self):
+        result = expand_filename_template(
+            "report_{author}_{from}_{to}.{ext}",
+            author="Кокос А.А.",
+            from_date="2026-06-01",
+            to_date="2026-06-30",
+            ext="xlsx",
+        )
+        assert result == "report_Кокос_А.А._2026-06-01_2026-06-30.xlsx"
+
+    def test_date_placeholder_dd_mm_yyyy(self):
+        result = expand_filename_template(
+            "отчёт_{date}.{ext}",
+            author="Кокос А.А.",
+            from_date="2026-03-01",
+            to_date="2026-03-31",
+            ext="odt",
+        )
+        assert result == "отчёт_31_03_2026.odt"
+
+    def test_no_placeholders_returns_unchanged(self):
+        result = expand_filename_template(
+            "report.odt",
+            author="Кокос А.А.",
+            from_date="2026-01-01",
+            to_date="2026-01-31",
+            ext="odt",
+        )
+        assert result == "report.odt"
+
+    def test_unknown_placeholder_left_as_is(self):
+        result = expand_filename_template(
+            "{author}_{unknown}.{ext}",
+            author="Кокос А.А.",
+            from_date="2026-01-01",
+            to_date="2026-01-31",
+            ext="xlsx",
+        )
+        assert result == "Кокос_А.А._{unknown}.xlsx"
+
+
+class TestResolveOutputPath:
+    """Tests for resolve_output_path()."""
+
+    def test_none_returns_none(self):
+        from redmine_reporter.yaml_config import resolve_output_path
+
+        assert resolve_output_path(None) is None
+
+    def test_explicit_path_with_known_extension_is_unchanged(self):
+        from redmine_reporter.yaml_config import resolve_output_path
+
+        result = resolve_output_path("/tmp/report.xlsx")
+        assert result == "/tmp/report.xlsx"
+
+    def test_explicit_path_with_unknown_extension_is_unchanged(self):
+        from redmine_reporter.yaml_config import resolve_output_path
+
+        result = resolve_output_path("report.odt")
+        assert result == "report.odt"
+
+    def test_no_extension_appends_default_format(self):
+        from redmine_reporter.yaml_config import resolve_output_path
+
+        result = resolve_output_path("report", default_format="xlsx")
+        assert result == "report.xlsx"
+
+    def test_no_extension_appends_custom_default_format(self):
+        from redmine_reporter.yaml_config import resolve_output_path
+
+        result = resolve_output_path("file", default_format="csv")
+        assert result == "file.csv"
+
+    def test_bare_format_name_resolves_to_template_path(self):
+        from redmine_reporter.yaml_config import resolve_output_path
+
+        result = resolve_output_path(
+            "xlsx",
+            output_dir="/tmp/reports",
+            filename_template="{date}.{ext}",
+            author="Кокос А.А.",
+            from_date="2026-06-01",
+            to_date="2026-06-30",
+            default_format="xlsx",
+        )
+        assert result == "/tmp/reports/30_06_2026.xlsx"
+
+    def test_bare_format_name_odt_resolves_to_template_path(self):
+        from redmine_reporter.yaml_config import resolve_output_path
+
+        result = resolve_output_path(
+            "odt",
+            output_dir="~/reports",
+            filename_template="{author}_{from}_{to}.{ext}",
+            author="Кокос А.А.",
+            from_date="2026-06-01",
+            to_date="2026-06-30",
+            default_format="xlsx",
+        )
+        assert result.startswith("/") and result.endswith(
+            "/reports/Кокос_А.А._2026-06-01_2026-06-30.odt"
+        )
+        assert "~" not in result
+
+    def test_bare_format_name_with_empty_output_dir_uses_cwd(self):
+        from redmine_reporter.yaml_config import resolve_output_path
+
+        result = resolve_output_path(
+            "csv",
+            output_dir="",
+            filename_template="report.{ext}",
+            author="A",
+            from_date="2026-01-01",
+            to_date="2026-01-31",
+        )
+        assert not result.startswith("/")
+        assert "report.csv" in result
+
+    def test_unknown_bare_format_is_treated_as_path(self):
+        from redmine_reporter.yaml_config import resolve_output_path
+
+        result = resolve_output_path("unknown_format")
+        assert result == "unknown_format.xlsx"
+
+
+class TestSavePeriodToConfig:
+    """Tests for save_period_to_config()."""
+
+    def test_creates_last_used_in_empty_config(self, tmp_path):
+        import yaml
+
+        from redmine_reporter.yaml_config import save_period_to_config
+
+        config_path = tmp_path / "config.yml"
+        save_period_to_config(str(config_path), "2026-06-01", "2026-06-30", "date", True)
+
+        with open(config_path) as fh:
+            data = yaml.safe_load(fh)
+
+        assert data["period"]["last_used"]["from"] == "2026-06-01"
+        assert data["period"]["last_used"]["to"] == "2026-06-30"
+        assert "default_from" not in data["period"]
+
+    def test_overwrites_existing_last_used(self, tmp_path):
+        import yaml
+
+        from redmine_reporter.yaml_config import save_period_to_config
+
+        config_path = tmp_path / "config.yml"
+        config_path.write_text(
+            "period:\n" "  last_used:\n" "    from: '2026-05-01'\n" "    to: '2026-05-31'\n"
+        )
+
+        save_period_to_config(str(config_path), "2026-06-01", "2026-06-30", "date", True)
+
+        with open(config_path) as fh:
+            data = yaml.safe_load(fh)
+
+        assert data["period"]["last_used"]["from"] == "2026-06-01"
+        assert data["period"]["last_used"]["to"] == "2026-06-30"
+
+    def test_dynamic_false_overwrites_defaults(self, tmp_path):
+        import yaml
+
+        from redmine_reporter.yaml_config import save_period_to_config
+
+        config_path = tmp_path / "config.yml"
+        config_path.write_text(
+            "period:\n" "  default_from: '2026-01-01'\n" "  default_to: '2026-01-31'\n"
+        )
+
+        save_period_to_config(str(config_path), "2026-06-01", "2026-06-30", "date", False)
+
+        with open(config_path) as fh:
+            data = yaml.safe_load(fh)
+
+        assert data["period"]["default_from"] == "2026-06-01"
+        assert data["period"]["default_to"] == "2026-06-30"
+        assert data["period"]["last_used"]["from"] == "2026-06-01"
+        assert data["period"]["last_used"]["to"] == "2026-06-30"
+
+    def test_datetime_precision_stores_timestamps(self, tmp_path):
+        import yaml
+
+        from redmine_reporter.yaml_config import save_period_to_config
+
+        config_path = tmp_path / "config.yml"
+
+        save_period_to_config(
+            str(config_path),
+            "2026-06-30T09:00:00",
+            "2026-06-30T12:00:00",
+            "datetime",
+            True,
+        )
+
+        with open(config_path) as fh:
+            data = yaml.safe_load(fh)
+
+        assert data["period"]["last_used"]["from"] == "2026-06-30T09:00:00"
+        assert data["period"]["last_used"]["to"] == "2026-06-30T12:00:00"
+
+    def test_preserves_existing_sections(self, tmp_path):
+        import yaml
+
+        from redmine_reporter.yaml_config import save_period_to_config
+
+        config_path = tmp_path / "config.yml"
+        config_path.write_text(
+            "redmine:\n"
+            "  url: https://example.com\n"
+            "  author: Test\n"
+            "output:\n"
+            "  dir: /tmp\n"
+        )
+
+        save_period_to_config(str(config_path), "2026-06-01", "2026-06-30", "date", True)
+
+        with open(config_path) as fh:
+            data = yaml.safe_load(fh)
+
+        assert data["redmine"]["url"] == "https://example.com"
+        assert data["redmine"]["author"] == "Test"
+        assert data["output"]["dir"] == "/tmp"
+        assert data["period"]["last_used"]["from"] == "2026-06-01"
+
+    def test_sets_permissions_0600(self, tmp_path):
+        from redmine_reporter.yaml_config import save_period_to_config
+
+        config_path = tmp_path / "config.yml"
+
+        save_period_to_config(str(config_path), "2026-06-01", "2026-06-30", "date", True)
+
+        mode = config_path.stat().st_mode & 0o777
+        assert mode == 0o600