Merge branch 'feature/71-my-tasks'

Tasks in the "Wishlist" bucket version are now excluded from the list
and summary entirely (no due date, noise backlog); exact case match,
tasks without a version are unaffected. Document --my-tasks in README
and the user guide (sorting, summary metrics, OSC 8 links, stream
separation); all examples use synthetic data. Declare ruff
known-first-party in pyproject so the lint result is CWD-independent.

.gitea/workflows/checks.yaml

@@ -0,0 +1,26 @@
+name: checks
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  checks:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: pip
+      - run: pip install -e .[dev]
+      - run: isort --check-only redmine_reporter tests
+      - run: black --check redmine_reporter tests
+      - run: ruff check redmine_reporter tests
+      - run: ruff format --check redmine_reporter tests
+      - run: mypy redmine_reporter
+      - run: pytest -v

README.md

@@ -1,32 +1,34 @@
 # redmine-reporter
 
-CLI-инструмент для генерации отчётов по задачам Redmine на основе записей о затраченном времени.
+[![checks](https://git.akokos.ru/artem.kokos/redmine-reporter/actions/workflows/checks.yaml/badge.svg)](https://git.akokos.ru/artem.kokos/redmine-reporter/actions)
 
-Проект предназначен для внутреннего использования с `https://red.eltex.loc/`.
+- [Возможности](#возможности)
+- [Установка](#установка)
+- [Быстрый старт](#быстрый-старт)
+- [Документация](#документация)
+- [Форматы вывода](#форматы-вывода)
+- [Разработка](#разработка)
+- [Безопасность](#безопасность)
+- [Лицензия](#лицензия)
 
-Лицензия: MIT.
+CLI-инструмент для генерации отчётов по задачам Redmine на основе записей о затраченном времени. Читает time entries текущего или указанного пользователя, группирует задачи по проекту и версии, выводит отчёт в консоль или экспортирует в файл. Предназначен для внутреннего использования с `https://red.eltex.loc/`.
 
 ## Возможности
 
-- Получение time entries **текущего** или **указанного** пользователя из Redmine.
-- Авторизация через Redmine API token или логин/пароль.
-- Группировка задач по проекту и версии.
-- Перевод статусов задач на русский язык.
-- Разбивка по типам активности (`--by-activity`).
-- Вывод в консоль (таблица / компактный вид).
-- Экспорт в ODT, CSV, Markdown, HTML, JSON и Excel (.xlsx).
-- Excel-отчёт с merge-ячейками по проекту/версии, итогами, автошириной, автофильтром и закреплённой шапкой.
-- Сводка по времени (`--summary`).
-- YAML-конфиг (`~/.config/redmine-reporter/config.yml`): шаблон имени файла, путь по умолчанию, период, email, настройки содержимого отчёта (`report.no_time`).
-- Умное разрешение `--output`: bare-формат (`xlsx`) → путь по шаблону, без расширения → автодописывание.
-- `--commit`: автосохранение отчёта в файл + фиксация периода в YAML-конфиге для следующего запуска.
-- `--send`: отправка отчёта по email через SMTP сразу после генерации.
-- HTML-версия тела письма при `--send`, если включено в YAML-конфиге (`email.html: true`).
-- Понятные сообщения об ошибках Redmine API, SMTP и файловой системы.
-- Загрузка альтернативного `.env` через `--config`.
+- Отчёт по time entries текущего или указанного пользователя (`--user-id`, `--user-login`, `--user-name`).
+- Группировка задач по проекту и версии, перевод статусов на русский язык.
+- Вывод в консоль (таблица или компактный вид) и экспорт в ODT, CSV, Markdown, HTML, JSON, XLSX.
+- Разбивка времени по типам активности (`--by-activity`), сводка (`--summary`), скрытие времени (`--no-time`).
+- Гибкий выбор периода: `--date`, env `FROM_DATE`, YAML `period.from`, по умолчанию — текущий месяц.
+- `--commit`: сохранение отчёта в файл и авто-сдвиг начала периода в конфиге для следующего запуска.
+- `--send`: отправка отчёта по email через SMTP (plain-text или HTML-письмо) с авто-сдвигом начала периода при успешной отправке.
+- `--my-tasks`: список назначенных вам открытых задач -- таблица с сортировкой по срочности (приоритет, срок версии) и сводкой; см. [руководство](docs/USER_GUIDE.md#список-открытых-задач).
+- YAML-конфиг с секретами через `${VAR}`; приоритет: CLI-флаги > env > .env > YAML > дефолты (нюанс с `--config` — см. docs/CONFIG.md).
 
 ## Установка
 
+Требуется Python >= 3.10.
+
 ```bash
 git clone https://git.akokos.ru/artem.kokos/redmine-reporter.git
 cd redmine-reporter
@@ -42,262 +44,43 @@ pip install .
 pip install -e ".[dev]"
 ```
 
-## Настройка
-
-Источники конфигурации (от высшего приоритета к низшему):
-
-```
-CLI-флаги  >  переменные окружения  >  .env  >  YAML-конфиг  >  кодовые дефолты
-```
-
-### YAML-конфиг (основной способ)
+## Быстрый старт
 
 ```bash
-# Сгенерировать YAML из текущего .env
+# Сгенерировать конфиг ~/.config/redmine-reporter/config.yml
 redmine-reporter --init-config
 
-# Редактировать под себя
+# Заполнить redmine.url, redmine.api_key (или ${REDMINE_API_KEY}), redmine.author
 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 можно не указывать — конец периода будет сегодня
-  default_to: "2026-06-30"
-  dynamic: false
-  # last_used заполняется --commit (см. docs/CONFIG.md)
-
-output:
-  dir: ~/reports
-  filename: "{author}_{from}_{to}.{ext}"
-  default_format: xlsx
-
-report:
-  no_time: false
-
-email:
-  html: false
-  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
-```
-
-Шаблон `output.filename` поддерживает `{author}`, `{from}`, `{to}`, `{date}` (DD_MM_YYYY), `{ext}`.
-
-Шаблоны `email.subject` и `email.body_text` поддерживают `{author}`, `{period}` (строка диапазона, например `2026-06-01--2026-06-30`).
-
-Подробнее: [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 можно не задавать — тогда конец периода будет сегодня
-DEFAULT_TO_DATE=2026-01-31
-```
-
-Переменные окружения:
-
-| Переменная | Обязательность | Описание |
-| --- | --- | --- |
-| `REDMINE_URL` | Да | URL Redmine. |
-| `REDMINE_API_KEY` | Да, если нет логина и пароля | Redmine API token. |
-| `REDMINE_USER` | Да, если нет токена | Логин Redmine. |
-| `REDMINE_PASSWORD` | Да, если нет токена | Пароль Redmine. |
-| `REDMINE_AUTHOR` | Нет | Имя автора для отчёта. |
-| `DEFAULT_FROM_DATE` | Нет | Начальная дата периода по умолчанию (`YYYY-MM-DD`). |
-| `DEFAULT_TO_DATE` | Нет | Конечная дата периода по умолчанию (`YYYY-MM-DD`). Если не задана, а `DEFAULT_FROM_DATE` задана — используется сегодняшняя дата. |
-| `REDMINE_VERIFY` | Нет | TLS-проверка: `true` / `false` / путь к CA bundle. |
-
-## Использование
-
-```bash
-source .venv/bin/activate
-```
-
-### Основные сценарии
-
-Отчёт за период по умолчанию:
-
-```bash
-redmine-reporter
-```
-
-Произвольный период:
-
-```bash
-redmine-reporter --date 2026-02-01--2026-02-28
-```
-
-Другой пользователь:
-
-```bash
-redmine-reporter --user-id 42
-redmine-reporter --user-login ivanov
-redmine-reporter --user-name "Иванов И.И."
-```
-
-Переопределить URL / API-ключ:
-
-```bash
-redmine-reporter --url https://red.example.com --api-key ваш_токен
-```
-
-Альтернативный `.env`:
-
-```bash
-redmine-reporter --config /path/to/.env
-```
-
-Компактный / отладочный вывод:
-
-```bash
-redmine-reporter --compact
-redmine-reporter --debug
-```
-
-### Экспорт в файл
-
-Явный путь:
-
-```bash
-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)
-```
-
-### Отправка по email (`--send`)
-
-Отправить отчёт на email, указанный в YAML-конфиге (секция `email`):
-
-```bash
-# Сохранить по шаблону и отправить
-redmine-reporter --date 2026-06-01--2026-06-30 --send
-
-# С явным путём
-redmine-reporter --date 2026-06-01--2026-06-30 --output ~/report.xlsx --send
-
-# Вместе с фиксацией периода
-redmine-reporter --date 2026-06-01--2026-06-30 --send --commit
-```
-
-Если в секции `email` установить `html: true`, письмо будет отправлено в двух версиях: plain-text и HTML (таблица отчёта прямо в теле письма). Файл отчёта всё равно прикрепляется, если `attach: true`.
-
-```yaml
-email:
-  html: true
-```
-
-Если секция `email` не настроена — ошибка с пояснением. При ошибке SMTP файл отчёта остаётся на диске, данные не теряются. Поддерживаются `to`, `cc`, `bcc`, TLS, отключение вложения (`attach: false`).
-
-### Фиксация периода (`--commit`)
-
-```bash
-# Сгенерировать, сохранить в файл по шаблону, запомнить период
-redmine-reporter --commit
-
-# С явным путём
-redmine-reporter --commit --output report.xlsx
-
-# Следующий запуск (без --date) возьмёт следующий период автоматически
+# Отчёт за текущий месяц в консоль
 redmine-reporter
 
-# При precision=datetime запоминает момент времени
-# (предотвращает дублирование записей внутри дня)
+# Сохранить в файл и сдвинуть начало периода для следующего запуска
 redmine-reporter --commit
+
+# Список ваших открытых задач (сортировка по срочности)
+redmine-reporter --my-tasks
 ```
 
-### Сводка и опции
+## Документация
 
-Без времени / с разбивкой по активностям:
-
-```bash
-redmine-reporter --no-time
-redmine-reporter --by-activity
-redmine-reporter --by-activity --summary
-```
-
-`--no-time` можно задать в YAML-конфиге (`report.no_time: true`), чтобы автоматические режимы (`--commit`, `--send`) не включали затраченное время без явного флага. При ручном `--output` YAML-значение не применяется — только CLI-флаг `--no-time`.
-
-Сводка:
-
-```bash
-redmine-reporter --summary
-```
+- [docs/USER_GUIDE.md](docs/USER_GUIDE.md) — руководство пользователя: сценарии использования, справочник всех CLI-флагов, устранение неполадок.
+- [docs/CONFIG.md](docs/CONFIG.md) — справочник конфигурации: YAML-структура, переменные окружения, приоритеты, безопасность.
 
 ## Форматы вывода
 
 | Формат | Особенности |
 | --- | --- |
-| **ODT** | Заголовок с автором и месяцем, группировка по проекту/версии. |
-| **CSV** | UTF-8 с BOM, полные значения `project`/`version` в каждой строке. |
-| **Markdown** | Компактная таблица, повторяющиеся группы скрыты. |
-| **HTML** | Полноценный HTML-документ с `meta charset="utf-8"`. |
-| **JSON** | Массив объектов: `project`, `version`, `issue_id`, `subject`, `status`, `time`. |
-| **Excel (.xlsx)** | Merge cells, колонки `Hours`/`Spent Time`, итоги, автоширина, автофильтр, freeze panes. |
+| Консоль | Таблица или компактный вид (`--compact`). |
+| ODT | Требуется `odfpy`; формирование по шаблону. |
+| CSV | UTF-8 с BOM; полные значения `project`/`version` в каждой строке. |
+| Markdown | Компактная таблица. |
+| HTML | Полный HTML-документ; объединение ячеек групп через rowspan. |
+| JSON | Объекты `project`, `version`, `issue_id`, `subject`, `status`, `time` + опционально `activities`. |
+| XLSX | Объединение ячеек по проекту/версии, итоги, автоширина (максимум 80), автофильтр, freeze panes. |
 
-## Полный список флагов
-
-```
---date DATE          Диапазон дат: YYYY-MM-DD--YYYY-MM-DD
---compact            Компактный текстовый вывод вместо таблицы
---output PATH/FMT    Путь к файлу (.odt/.csv/.md/.html/.json/.xlsx)
-                     или bare-формат (xlsx/odt/...) — путь из конфига
---author NAME        Переопределить имя автора
---no-time            Не включать затраченное время в таблицу
---url URL            Переопределить Redmine URL
---api-key KEY        Переопределить Redmine API key
---config PATH        Путь к альтернативному .env-файлу
---verbose            Подробный вывод
---debug              Отладочный вывод
---version            Показать версию и выйти
---summary            Вывести сводку по времени в stderr
---user-id ID         Redmine ID пользователя для отчёта
---user-login LOGIN   Логин пользователя Redmine
---user-name NAME     Полное имя пользователя Redmine
---by-activity        Разбить время по типам активности
---init-config        Сгенерировать YAML-конфиг и выйти
---force              Перезаписать существующий конфиг (с --init-config)
---config-path PATH   Путь к YAML-конфигу (по умолчанию ~/.config/redmine-reporter/config.yml)
---commit             Сохранить отчёт в файл и зафиксировать период в конфиге
---send               Отправить отчёт по email после сохранения
-```
+Нюанс `--no-time`: физически удаляет колонку времени только CSV; в XLSX колонки остаются, но пустыми и без итогов; в остальных форматах — пустые значения.
 
 ## Разработка
 
@@ -305,15 +88,23 @@ redmine-reporter --summary
 
 ```bash
 pytest
+isort --check-only redmine_reporter tests
+black --check redmine_reporter tests
 ruff check redmine_reporter tests
 ruff format --check redmine_reporter tests
 mypy redmine_reporter
 ```
 
+CI — Gitea Actions (`.gitea/workflows/checks.yaml`): все шесть проверок на матрице Python 3.10–3.13.
+
 ## Безопасность
 
-- Не коммитьте `.env`, API token, пароль или логин.
-- YAML-конфиг имеет права `0600`, директория — `0700`.
-- Рекомендуется хранить секреты через `${VAR}`, а не plaintext.
-- Используйте аккаунт с минимальными правами, достаточными для чтения time entries и задач.
-- Инструмент работает только в режиме чтения и не изменяет данные в Redmine.
+- `REDMINE_URL` обязан использовать HTTPS: валидация отклоняет остальное, API-ключ передаётся в заголовках.
+- `verify_ssl` / `REDMINE_VERIFY`: `true` (по умолчанию — проверка по системному хранилищу CA операционной системы через truststore, корпоративные CA из ОС работают), `false` (предупреждение о MITM-риске при старте) или путь к CA-bundle.
+- Конфиг создаётся с правами `0600`, директория — `0700`; при более широких правах выводится предупреждение.
+- Секреты храните через `${VAR}` в YAML или в переменных окружения, не в открытом виде.
+- Инструмент только читает данные из Redmine и ничего в нём не изменяет.
+
+## Лицензия
+
+MIT, см. [LICENSE](LICENSE).

docs/CONFIG.md

@@ -1,5 +1,32 @@
 # Настройка redmine-reporter
 
+## Оглавление
+
+- [Источники конфигурации](#источники-конфигурации)
+- [YAML-конфиг](#yaml-конфиг)
+  - [Структура](#структура)
+  - [`redmine.verify_ssl` — проверка TLS-сертификата](#redmineverify_ssl--проверка-tls-сертификата)
+  - [`period.from` — начало окна отчёта](#periodfrom--начало-окна-отчёта)
+  - [`--date` — формат диапазона](#--date--формат-диапазона)
+  - [Авто-сдвиг начала периода](#авто-сдвиг-начала-периода)
+  - [Миграция старых ключей периода](#миграция-старых-ключей-периода)
+  - [`email` — настройка отправки по почте](#email--настройка-отправки-по-почте)
+  - [`--send` — отправка отчёта по email](#--send--отправка-отчёта-по-email)
+  - [`output` — путь и имя файла по умолчанию](#output--путь-и-имя-файла-по-умолчанию)
+  - [Подстановка переменных окружения](#подстановка-переменных-окружения)
+  - [`report` — настройки содержимого отчёта](#report--настройки-содержимого-отчёта)
+  - [`report.status_translation` — перевод статусов](#reportstatus_translation--перевод-статусов)
+- [Разрешение выходного пути](#разрешение-выходного-пути)
+- [Миграция с `.env` на YAML](#миграция-с-env-на-yaml)
+  - [Быстрый старт](#быстрый-старт)
+  - [Что делает `--init-config`](#что-делает---init-config)
+  - [Флаги миграции](#флаги-миграции)
+  - [Проверка после миграции](#проверка-после-миграции)
+  - [Сосуществование `.env` и YAML](#сосуществование-env-и-yaml)
+  - [Откат](#откат)
+- [`.env` (legacy)](#env-legacy)
+- [Безопасность](#безопасность)
+
 ## Источники конфигурации
 
 Приоритет, от высшего к низшему:
@@ -8,6 +35,9 @@
 CLI-флаги  >  переменные окружения  >  .env  >  YAML  >  кодовые дефолты
 ```
 
+Нюанс с `override` при автозагрузке `.env` и `--config` — см.
+[Сосуществование `.env` и YAML](#сосуществование-env-и-yaml).
+
 Если значение не задано на верхнем уровне, берётся уровень ниже. `.env` и YAML
 работают одновременно — можно оставить оба, можно удалить `.env` после миграции.
 
@@ -30,14 +60,7 @@ redmine:
   verify_ssl: true
 
 period:
-  precision: date
-  default_from: "2026-06-01"
-  # default_to можно не указывать — тогда конец периода будет сегодня
-  default_to: "2026-06-30"
-  dynamic: false
-  last_used:
-    from: "2026-06-30T09:00:00"
-    to: "2026-06-30T12:00:00"
+  from: "2026-06-01"
 
 output:
   dir: ~/reports
@@ -65,66 +88,128 @@ email:
   attach: true
 ```
 
-### `period.precision` — точность периода
+### `redmine.verify_ssl` — проверка TLS-сертификата
 
-Определяет, как вычисляется следующий период после фиксации:
+Управляет проверкой TLS-сертификата Redmine. Семантика едина с переменной
+окружения `REDMINE_VERIFY`:
 
-- `date` (по умолчанию) — период с точностью до дня. Следующий запуск (после `--commit`) начинается со следующего дня.
-- `datetime` — период с точностью до секунды. При повторном запуске time entries с `created_on` и `updated_on` ранее `last_used.to` исключаются (AND-логика: запись исключается только если **оба** поля раньше cutoff). Это предотвращает дублирование при отправке отчёта внутри рабочего дня.
+| Значение | Поведение |
+|---|---|
+| `true` (по умолчанию) | Проверка по системному хранилищу CA операционной системы (через truststore) — корпоративные CA, добавленные в ОС, работают без настройки |
+| `false` | Проверка отключена — при запуске выводится предупреждение о риске MITM |
+| строка с путём, например `/etc/ssl/my-ca.pem` | Путь к собственному CA-bundle, передаётся в requests как есть |
 
-`last_used.from` / `last_used.to` записываются автоматически при `--commit`. Вручную редактировать не требуется.
+До версии с унификацией `verify_ssl: true` подставлял захардкоженный путь
+`/etc/ssl/certs/ca-certificates.crt`, который существует только в
+Debian/Ubuntu. Теперь `true` в YAML и `REDMINE_VERIFY=true` в env работают
+одинаково — оба включают проверку по системному хранилищу CA на любой ОС
+(через truststore), без привязки к конкретному пути.
 
-### `period.default_to` — необязательное окончание периода
+### `period.from` — начало окна отчёта
 
-Если `period.default_to` не задан, а `period.default_from` задан, инструмент
-использует сегодняшнюю дату в качестве конца периода.
+Единственный ключ периода в YAML. Дата в формате `YYYY-MM-DD`:
 
 ```yaml
 period:
-  default_from: "2026-07-01"
-  # default_to отсутствует → конец периода = сегодня
+  from: "2026-06-01"
 ```
 
-Это предотвращает устаревание периода, когда отчёт генерируется автоматически
-(`--send`, `--commit`) без явного `--date`.
+Окно отчёта — `from..сегодня`: конец окна всегда сегодняшняя дата и отдельно
+не настраивается. Переменная окружения `FROM_DATE` задаёт то же начало и имеет
+приоритет над YAML:
 
-Аналогично работает `DEFAULT_TO_DATE`: если переменная не задана, а
-`DEFAULT_FROM_DATE` задана, конец периода = сегодня.
+```
+--date  >  FROM_DATE (env)  >  period.from (YAML)  >  1-е число текущего месяца
+```
 
-### `--commit` — автофиксация периода
+Разрешение начала окна:
 
-Флаг `--commit` сохраняет использованный период в YAML-конфиг, чтобы следующий запуск автоматически начинался с нового периода.
+| Условие | Начало окна |
+|---|---|
+| `from` не задан (`FROM_DATE` и `period.from` пусты) | 1-е число текущего месяца |
+| `from` — корректная дата | `from` |
+| `from` позже сегодняшней даты | сегодня (окно «сегодня--сегодня») |
+| `from` некорректна (не `YYYY-MM-DD`) | warning в stderr + 1-е число текущего месяца |
 
-**Что делает:**
+Граничный день (день коммита) становится началом следующего окна и потому
+перечитывается: уже отправленные записи этого дня повторятся в следующем
+отчёте. Это осознанное следствие отсутствия дедупликации; зато поздние
+записи, добавленные в Redmine в день коммита после отправки, не теряются.
+Повторный запуск `--commit`/`--send` в тот же день даёт окно
+«сегодня--сегодня».
 
-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.from` записывается автоматически при `--commit`/`--send`; вручную
+редактировать не требуется.
 
-**Поведение `period.dynamic`:**
+### `--date` — формат диапазона
 
-- `dynamic: true` — следующий запуск (без `--date`) вычисляет период от `last_used`:
-  - Полный календарный месяц → следующий полный месяц.
-  - Произвольный диапазон → та же длительность, начиная со дня после `last_used.to`.
-- `dynamic: false` — `--commit` перезаписывает `default_from`/`default_to` на использованный период.
+Флаг `--date` задаёт диапазон явно и переопределяет все остальные источники.
+Каждая граница — дата `YYYY-MM-DD` или datetime `YYYY-MM-DDTHH:MM:SS`:
 
-**Примеры:**
+- `2026-06-01--2026-06-30`;
+- `2026-06-30T09:00:00--2026-06-30T12:00:00`.
+
+Время в границах отбрасывается — окно всегда состоит из полных дней, так как
+гранулярность Redmine — день. Границы можно смешивать (дата + datetime).
+Начало позже конца (`start > end`) — ошибка.
+
+### Авто-сдвиг начала периода
+
+`--commit` и `--send` генерируют отчёт, сохраняют его в файл (по `--output`
+или по шаблону `output.dir`/`output.filename`) и сдвигают начало окна.
+`--send` дополнительно отправляет отчёт по email (см.
+[ниже](#--send--отправка-отчёта-по-email)).
+
+После успешного `--commit` (файл сохранён) или реальной отправки `--send`
+(подтверждение «y» + успешная отправка) в конфиг пишется
+`period.from = <конец окна отчёта>`. Следующий запуск без `--date` начинает
+окно с граничного дня последнего отчёта.
+
+Сдвиг НЕ происходит:
+
+- если за период нет time entries (отчёт пуст — выход до сохранения);
+- при отказе от подтверждения отправки в `--send` (ответ не «y»/«yes»);
+- при ошибке SMTP в `--send` (соединение, аутентификация, таймаут);
+- при ошибке сохранения файла отчёта.
+
+Исключение: при явном `--commit` (сочетание `--send --commit`) отказ от
+подтверждения отправки сдвиг не отменяет: окно всё равно сдвигается по
+`--commit`.
+
+При сочетании `--send --commit` ошибка SMTP подавляет и сдвиг по `--commit`:
+файл остаётся сохранён, но начало периода не двигается.
+
+Примеры:
 
 ```bash
-# Июнь 2026 → следующий запуск (без --date) → июль 2026
+# Окно 1--30 июня → следующий запуск (без --date) начнётся с 30 июня
 redmine-reporter --date 2026-06-01--2026-06-30 --commit
 
-# Произвольный диапазон: 15-20 июня → следующий запуск → 21-26 июня
+# Произвольный диапазон 15--20 июня → следующее окно с 20 июня
 redmine-reporter --date 2026-06-15--2026-06-20 --commit
 
-# С datetime-точностью: повторный запуск не дублирует записи
-redmine-reporter --commit
+# Отправить и сдвинуть окно (только при подтверждении «y» и успехе)
+redmine-reporter --date 2026-06-01--2026-06-30 --send --commit
 ```
 
+`--commit`/`--send` перезаписывают только `period.from`; остальные секции и
+ключи YAML сохраняются. Файл перезаписывается через `yaml.dump` —
+пользовательские комментарии и ручное форматирование теряются.
+
+### Миграция старых ключей периода
+
+Старые ключи периода больше не читаются и тихо игнорируются при загрузке —
+их можно удалить из YAML:
+
+- `period.last_used` (включая `from`/`to`);
+- `period.precision`;
+- `period.dynamic`;
+- `period.default_from` / `period.default_to`.
+
+Env `DEFAULT_FROM_DATE` / `DEFAULT_TO_DATE` заменены на `FROM_DATE`; конец
+периода больше не настраивается (всегда сегодня). Дедупликация time entries
+по `created_on`/`updated_on` удалена.
+
 ### `email` — настройка отправки по почте
 
 Секция `email` используется флагом `--send`. Если секция не настроена или `smtp.host`
@@ -193,8 +278,10 @@ email:
 
 ### `--send` — отправка отчёта по email
 
-Флаг `--send` отправляет сгенерированный отчёт через SMTP сразу после сохранения
-в файл. Требует настроенную секцию `email` в YAML-конфиге.
+Флаг `--send` сохраняет отчёт в файл, отправляет его через SMTP и сдвигает
+начало периода при подтверждении и успешной отправке (см.
+[Авто-сдвиг](#авто-сдвиг-начала-периода)). Требует настроенную
+секцию `email` в YAML-конфиге.
 
 **Что делает:**
 
@@ -202,10 +289,14 @@ email:
 2. Сохраняет отчёт в файл:
    - Если указан `--output` — по явному пути.
    - Если `--output` не указан — по шаблону из `output.dir` / `output.filename`.
-3. Формирует MIME-письмо:
+3. Запрашивает подтверждение: «Отправить? [y/N]». Ответ «y»/«yes» продолжает,
+   иначе отправка отменяется (без сдвига периода).
+4. Формирует MIME-письмо:
    - Тема, plain-text тело и вложение (если `attach: true`).
    - При `email.html: true` — дополнительно HTML-версия тела (`multipart/alternative`), сгенерированная из таблицы отчёта.
-4. Отправляет через SMTP с TLS (таймаут 30 секунд).
+5. Отправляет через SMTP (таймаут 30 секунд). STARTTLS включается только при
+   `email.smtp.tls: true`; аутентификация — только если задан `email.smtp.user`.
+6. При успешной отправке сдвигает начало периода.
 
 **Файл отчёта сохраняется до попытки отправки** — при ошибке SMTP файл остаётся
 на диске, данные не теряются.
@@ -228,7 +319,7 @@ redmine-reporter --date 2026-06-01--2026-06-30 --send
 # С явным путём
 redmine-reporter --date 2026-06-01--2026-06-30 --output ~/report.xlsx --send
 
-# Отправить и зафиксировать период
+# Отправить и сдвинуть начало периода
 redmine-reporter --date 2026-06-01--2026-06-30 --send --commit
 ```
 
@@ -238,7 +329,7 @@ redmine-reporter --date 2026-06-01--2026-06-30 --send --commit
 |---|---|
 | `--send` | Сохранить по шаблону → отправить |
 | `--send --output X` | Сохранить в X → отправить |
-| `--send --commit` | Сохранить → отправить → зафиксировать период |
+| `--send --commit` | Сохранить → подтвердить → отправить → сдвинуть начало периода |
 | `--send` с `email.html: true` | Письмо с plain-text + HTML-таблицей |
 | `--send` без `email` в конфиге | Ошибка, exit 1 |
 | `--send` при ошибке SMTP | Файл сохранён, ошибка в stderr, exit 1 |
@@ -307,6 +398,7 @@ email:
 | Поле | Тип | По умолчанию | Описание |
 |---|---|---|---|
 | `no_time` | bool | `false` | Не включать затраченное время в файл отчёта |
+| `status_translation` | map[str,str] | `{}` | Переопределение/дополнение перевода статусов |
 
 `report.no_time` применяется только в автоматических режимах (`--commit`, `--send`).
 При ручном `--output` YAML-настройка игнорируется — там работает только CLI-флаг `--no-time`.
@@ -330,6 +422,22 @@ redmine-reporter --output report.odt
 redmine-reporter --output report.odt --no-time
 ```
 
+### `report.status_translation` — перевод статусов
+
+По умолчанию статусы Redmine переводятся встроенным словарём
+(`New` → `В работе`, `Closed` → `Закрыто` и т.д.). Секция
+`report.status_translation` переопределяет отдельные переводы и/или
+добавляет новые статусы; не указанные здесь статусы переводятся
+встроенным словарём, а совсем неизвестные выводятся как есть.
+
+```yaml
+report:
+  status_translation:
+    "New": "Новая"
+    "Wait Release": "Ожидает релиза"
+    "Custom Status": "Кастомный статус"
+```
+
 ## Разрешение выходного пути
 
 Функция `resolve_output_path()` определяет итоговый путь к файлу:
@@ -338,7 +446,7 @@ redmine-reporter --output report.odt --no-time
 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` (неизвестное расширение) → используется как есть, форматтер выбирается по расширению.
+5. `--output /path/report.xyz` (неизвестное расширение) → ошибка «Неизвестный формат файла», exit 1.
 
 ## Миграция с `.env` на YAML
 
@@ -358,7 +466,8 @@ vim ~/.config/redmine-reporter/config.yml
 ### Что делает `--init-config`
 
 - Читает текущие значения из `.env` и переменных окружения.
-- Формирует YAML со всеми секциями (`redmine`, `period`, `output`, `email`).
+- Формирует YAML со всеми секциями (`redmine`, `period`, `output`, `report`, `email`).
+- В конец файла дописывает закомментированный пример `report.status_translation`.
 - Секреты (`REDMINE_API_KEY`, `SMTP_PASSWORD`) записывает как `${VAR}`, если
   переменная существует, иначе — пустая строка.
 - Создаёт файл с правами `0600`, директорию — с `0700`.
@@ -369,11 +478,10 @@ vim ~/.config/redmine-reporter/config.yml
 |---|---|
 | `--init-config` | Создать YAML и выйти |
 | `--init-config --force` | Перезаписать существующий YAML |
-| `--config-path PATH` | Сохранить YAML по указанному пути (по умолчанию `~/.config/redmine-reporter/config.yml`) |
+| `--config-path PATH` | Путь к YAML-конфигу: загрузка при запуске, запись при `--init-config` и `--commit` (по умолчанию `~/.config/redmine-reporter/config.yml`) |
 
-Если `DEFAULT_TO_DATE` не задана, а `DEFAULT_FROM_DATE` задана, сгенерированный
-YAML будет содержать пустое `default_to`, и при запуске инструмент использует
-сегодняшнюю дату.
+Если задана `FROM_DATE`, сгенерированный YAML будет содержать `period.from` с
+этим значением.
 
 ### Проверка после миграции
 
@@ -401,6 +509,10 @@ ls -la ~/.config/redmine-reporter/
 YAML работает как базовый слой для всего, что не в .env
 ```
 
+Автозагрузка `.env` (без `--config`) не перебивает реальные переменные
+окружения (`override=False`). Исключение — `--config FILE`: указанный `.env`
+загружается с `override=True` и перебивает переменные окружения (но не CLI-флаги).
+
 Это safe — если с YAML что-то пойдёт не так, просто положи `.env` обратно.
 
 ### Откат
@@ -411,18 +523,19 @@ rm ~/.config/redmine-reporter/config.yml
 
 ## `.env` (legacy)
 
-Для обратной совместимости `.env` продолжает работать без изменений.
+Для обратной совместимости `.env` продолжает работать как раньше, кроме ключей
+периода: `DEFAULT_FROM_DATE` заменён на `FROM_DATE`, `DEFAULT_TO_DATE` удалён
+(см. [Миграция старых ключей периода](#миграция-старых-ключей-периода)).
 
 ```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
+FROM_DATE=2026-06-01
 ```
 
 Если ни `.env`, ни YAML не заданы — используются кодовые дефолты (текущий месяц
-как период, стандартный путь сертификатов, пустой автор).
+как период, стандартная проверка TLS, пустой автор).
 
 ## Безопасность
 

docs/USER_GUIDE.md

@@ -0,0 +1,381 @@
+# Руководство пользователя redmine-reporter
+
+## Оглавление
+
+- [Установка](#установка)
+- [Первоначальная настройка](#первоначальная-настройка)
+- [Выбор периода](#выбор-периода)
+- [Отчёт за другого пользователя](#отчёт-за-другого-пользователя)
+- [Список открытых задач](#список-открытых-задач)
+- [Экспорт в файл](#экспорт-в-файл)
+- [Содержимое отчёта](#содержимое-отчёта)
+- [Отправка по email](#отправка-по-email)
+- [Скользящее окно периода](#скользящее-окно-периода)
+- [Справочник флагов](#справочник-флагов)
+- [Устранение неполадок](#устранение-неполадок)
+- [См. также](#см-также)
+
+## Установка
+
+Требуется Python >= 3.10.
+
+```bash
+git clone https://git.akokos.ru/artem.kokos/redmine-reporter.git
+cd redmine-reporter
+python3 -m venv .venv
+source .venv/bin/activate
+pip install --upgrade pip
+pip install .
+```
+
+Проверка:
+
+```bash
+redmine-reporter --version
+```
+
+Перед каждым запуском активируйте окружение: `source .venv/bin/activate`.
+
+## Первоначальная настройка
+
+1. Убедитесь, что в текущей директории есть `.env` с `REDMINE_URL` и `REDMINE_API_KEY` (или задайте эти переменные в окружении).
+2. Сгенерируйте YAML-конфиг:
+
+```bash
+redmine-reporter --init-config
+```
+
+Результат: файл `~/.config/redmine-reporter/config.yml` (права `0600`, директория `0700`) со всеми секциями и закомментированным примером `report.status_translation`. Секреты, заданные в окружении, записываются как `${VAR}`.
+
+3. Если файл уже существует — ошибка; для перезаписи добавьте `--force`:
+
+```bash
+redmine-reporter --init-config --force
+```
+
+4. Нестандартное расположение конфига:
+
+```bash
+redmine-reporter --init-config --config-path /etc/redmine-reporter/config.yml
+```
+
+`--config-path` задаёт путь и для загрузки YAML, и для записи при `--init-config` и `--commit`.
+
+5. Откройте файл и заполните минимум: `redmine.url`, `redmine.api_key`, `redmine.author`.
+
+`--init-config` несовместим с флагами отчёта (`--date`, `--output`, `--compact`, `--summary`, `--user-id`/`--user-login`/`--user-name`, `--no-time`, `--by-activity`, `--send`) — указывайте его отдельно.
+
+Полный референс всех секций и переменных: [CONFIG.md](CONFIG.md).
+
+## Выбор периода
+
+Окно отчёта — диапазон дат `from..to`. Конец (`to`) всегда сегодняшняя дата,
+если диапазон не задан явно через `--date`.
+
+Приоритет начала окна (от высшего к низшему):
+
+1. `--date` — явный диапазон (полностью переопределяет окно).
+2. `FROM_DATE` (env) — начало; конец — сегодня.
+3. `period.from` (YAML) — начало; конец — сегодня.
+4. Ничего не задано — текущий месяц: с 1-го числа по сегодня.
+
+Форматы `--date`:
+
+```bash
+# Даты
+redmine-reporter --date 2026-06-01--2026-06-30
+
+# Дата-время (границы флорятся до полных дней)
+redmine-reporter --date 2026-06-01T09:00:00--2026-06-01T18:00:00
+```
+
+Границы с временем округляются до дат — отчёт строится за полные дни диапазона.
+Границы можно смешивать (дата + дата-время). Начало позже конца
+(`start > end`) — ошибка.
+
+Краевые случаи:
+
+- `from` позже сегодняшней даты — окно «сегодня--сегодня».
+- `from` некорректна (не `YYYY-MM-DD`) — warning + текущий месяц.
+
+## Отчёт за другого пользователя
+
+Без флагов отчёт строится за текущего пользователя.
+
+```bash
+redmine-reporter --user-id 42
+redmine-reporter --user-login ivanov
+redmine-reporter --user-name "Иванов Иван Иванович"
+```
+
+Правила:
+
+- Флаги `--user-id`, `--user-login`, `--user-name` взаимоисключающие: укажите только один, иначе ошибка.
+- Все три принимают одно значение. Число или строка из цифр → поиск по ID. Иначе — точное регистрозависимое совпадение логина.
+- Если по логину совпадений нет — поиск по имени. Одно совпадение → пользователь найден.
+- Несколько совпадений по имени → ошибка «Multiple users match...» со списком логинов (при дублях логина — ID).
+- Ноль совпадений → ошибка «User '...' not found...».
+
+## Список открытых задач
+
+`--my-tasks` -- отдельный режим: вместо отчёта по затраченному времени выводит
+открытые задачи, назначенные на вас, по всем проектам. Отчётное окно периода
+к режиму не применяется.
+
+```bash
+redmine-reporter --my-tasks                       # задачи владельца API-ключа
+redmine-reporter --my-tasks --user-id 42          # чужой список по ID
+redmine-reporter --my-tasks --user-login ivanov   # по логину
+```
+
+Правила:
+
+- `--user-id` / `--user-login` / `--user-name` выбирают, чей список показать; по умолчанию -- владелец API-ключа. Разрешение пользователей то же, что для отчёта (см. [Отчёт за другого пользователя](#отчёт-за-другого-пользователя)).
+- `--url`, `--api-key`, `--config`, `--config-path`, `--verbose`, `--debug` работают как обычно.
+- Совмещение с отчётными флагами (`--date`, `--output`, `--compact`, `--summary`, `--no-time`, `--by-activity`, `--commit`, `--send`) -- ошибка «--my-tasks cannot be used with report-generating flags.», exit 1.
+- Задачи в версии `Wishlist` исключаются из режима целиком: не попадают ни в таблицу, ни в сводку.
+
+Сортировка -- от срочного к менее срочному:
+
+1. Приоритет `P1..P5`: меньший номер срочнее; неизвестное имя приоритета получает низший ранг.
+2. Внутри приоритетной группы -- срок версии (due date) по возрастанию.
+3. Задачи без версии или без срока -- в конец своей приоритетной группы.
+4. При прочих равных -- по возрастанию ID.
+
+Таблица печатается в stdout, сводка -- в stderr перед таблицей. При
+перенаправлении (`redmine-reporter --my-tasks > tasks.txt`) в файл попадает
+только таблица.
+
+Колонки таблицы: ID | Тема | Статус | Приор. | Версия | Срок. Пример
+(синтетические данные, ID в терминале кликабелен):
+
+```
+  ID  Тема                              Статус          Приор.    Версия    Срок
+----  --------------------------------  --------------  --------  --------  --------------
+ 101  Критический дефект сборки образа  В работе        P1        v2.4.0    2026-10-15 (!)
+ 102  Обновить документацию API         Новая           P2        v2.5.0    2026-12-01
+ 103  Ревью pull request                Обратная связь  P3        -         -
+```
+
+- ID -- гиперссылка (OSC 8) на страницу задачи `<url>/issues/<id>`: в терминалах с поддержкой кликабельна, без поддержки остаётся обычным номером.
+- Срок -- дата релиза целевой версии; просроченный (раньше сегодняшней даты) помечается `(!)`.
+- Пустые «Версия» и «Срок» -- прочерк `-`.
+- Статусы переводятся на русский тем же словарём, что и в отчётах: встроенный словарь + `report.status_translation` (см. [Перевод статусов](#перевод-статусов)).
+
+Сводка (пример с синтетическими данными):
+
+```
+Открытых: 3 | просроченных: 1 | без версии: 1 | без срока: 0 | потрачено: 12.5h | оценка: 8h (по 2 из 3)
+```
+
+- «просроченных» -- задачи со сроком версии раньше сегодняшней даты.
+- «без версии» -- задачи без целевой версии; «без срока» -- задачи с версией, но без известной даты релиза.
+- «потрачено» -- сумма полей `spent_hours` задач списка.
+- «оценка» -- сумма полей `estimated_hours`; «(по N из M)» -- у скольких задач из списка есть оценка. Если оценок нет ни у одной задачи, блок «оценка» не выводится.
+
+Сроки версий дозагружаются отдельным запросом на каждую уникальную версию
+списка. Недоступная версия -- предупреждение в stderr и пустой срок у её
+задач, вывод не прерывается.
+
+Пустой список (в том числе когда все открытые задачи попали в исключаемую
+версию `Wishlist`): «ℹ️  Открытых задач нет.» (stderr), exit 0.
+
+## Экспорт в файл
+
+Флаг `--output` определяется по четырём правилам:
+
+| Аргумент | Результат |
+| --- | --- |
+| `--output xlsx` (bare-формат: `xlsx`, `odt`, `csv`, `md`, `html`, `json`, регистронезависимо) | Путь = `output.dir` + шаблон `output.filename` из YAML, расширение = указанный формат |
+| `--output /tmp/report` (путь без расширения) | Дописывается `.` + `output.default_format` → `/tmp/report.xlsx` |
+| `--output /tmp/report.csv` (путь с любым расширением) | Используется как есть |
+| `--output /tmp/report.xyz` (неизвестное расширение) | Ошибка «Неизвестный формат файла: '.xyz'. Поддерживаются: .odt, .csv, .md, .html, .json, .xlsx», exit 1 |
+
+Формат `.odt` требует установленного пакета `odfpy` (устанавливается по умолчанию) — иначе отдельная ошибка.
+
+Примеры:
+
+```bash
+redmine-reporter --output xlsx                    # по шаблону в output.dir
+redmine-reporter --output 2026-06-report          # → 2026-06-report.xlsx (если default_format: xlsx)
+redmine-reporter --output reports/june.csv        # как есть
+```
+
+Плейсхолдеры `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` |
+
+Неизвестные плейсхолдеры остаются в имени как есть.
+
+Нюансы с путями:
+
+- `~` в явном `--output` раскрывает шелл, а не программа: `redmine-reporter --output ~/report.xlsx` работает, а в кавычках (`"~/report.xlsx"`) — нет.
+- `expanduser` применяется только к `output.dir` из YAML.
+
+## Содержимое отчёта
+
+### `--no-time`
+
+Убирает затраченное время из отчёта. Физически удаляет колонку времени только CSV. XLSX, HTML, ODT, Markdown, JSON и консольный вывод оставляют пустые колонки/поля; в XLSX дополнительно пропадают строки итогов по версиям/проектам/всего.
+
+```bash
+redmine-reporter --output report.xlsx --no-time
+```
+
+YAML-настройка `report.no_time` действует только в автоматических режимах (`--commit`, `--send`). При ручном `--output` работает только CLI-флаг.
+
+### `--by-activity`
+
+Разбивка затраченного времени по типам активности. В JSON-отчёте добавляется поле `activities`.
+
+```bash
+redmine-reporter --by-activity
+```
+
+### `--summary`
+
+Печатает сводку в stderr (после отчёта):
+
+- `total` — суммарное время;
+- `project:*` — время по каждому проекту;
+- `activity:*` — время по каждой активности (только при одновременном `--by-activity`).
+
+Версии в сводку не входят.
+
+```bash
+redmine-reporter --by-activity --summary
+```
+
+### `--compact`
+
+Компактный текстовый вывод в консоль вместо таблицы:
+
+```bash
+redmine-reporter --compact
+```
+
+### Перевод статусов
+
+Статусы задач переводятся встроенным словарём; секция `report.status_translation` переопределяет или дополняет переводы. Подробно: [CONFIG.md](CONFIG.md).
+
+## Отправка по email
+
+Требуется секция `email` в YAML-конфиге (см. [CONFIG.md](CONFIG.md)).
+
+```bash
+redmine-reporter --date 2026-06-01--2026-06-30 --send
+redmine-reporter --date 2026-06-01--2026-06-30 --output report.xlsx --send
+redmine-reporter --send --commit
+```
+
+Факты:
+
+- Файл отчёта сохраняется на диск ДО отправки: при ошибке SMTP файл остаётся на месте.
+- Перед отправкой запрашивается подтверждение «Отправить? [y/N]»; ответ «y»/«yes» продолжает, иначе отправка отменяется (без сдвига периода, если не задан явный `--commit`).
+- При успешной отправке начало периода сдвигается (см. [Скользящее окно периода](#скользящее-окно-периода)); при отмене (если не задан явный `--commit`) или ошибке SMTP — без сдвига.
+- Секция `email` отсутствует или `smtp.host` пуст → ошибка «Email не настроен. Добавьте секцию 'email' в конфиг...», exit 1.
+- `email.html: true` → письмо `multipart/alternative`: plain-text + HTML-таблица отчёта в теле.
+- Файл прикрепляется при `attach: true`; MIME-тип определяется по расширению, неизвестное → `application/octet-stream`.
+- Получатели `bcc` указываются только в envelope (не видны в заголовках письма).
+- STARTTLS применяется только при `smtp.tls: true`; аутентификация на SMTP-сервере — только если задан `smtp.user`.
+- Таймаут соединения с SMTP — 30 секунд.
+
+Точные тексты ошибок:
+
+- «Ошибка аутентификации SMTP. Проверьте логин и пароль.»
+- «Таймаут соединения с SMTP-сервером.»
+- «Ошибка отправки письма: ...»
+- «Не удалось подключиться к SMTP-серверу host:port»
+
+## Скользящее окно периода
+
+После успешного `--commit` (файл сохранён) или реальной отправки `--send`
+(подтверждение «y» + успех) окно отчёта сдвигается вперёд: в конфиг пишется
+`period.from = <конец окна>`. Следующий запуск без `--date`
+начинается с граничного дня последнего отчёта.
+
+Типичный цикл:
+
+```bash
+# 1. Отчёт за июнь 2026: сохранить, отправить, сдвинуть начало на 30 июня
+redmine-reporter --date 2026-06-01--2026-06-30 --send --commit
+
+# 2. Следующий запуск без --date берёт окно с 30 июня по сегодня
+redmine-reporter --send --commit
+```
+
+Граничный день: начало следующего окна совпадает с днём коммита, поэтому этот
+день перечитывается. Записи дня коммита, уже попавшие в прошлый отчёт,
+повторятся (дедупликации по `created_on`/`updated_on` нет — это осознанное
+следствие), зато поздние записи, добавленные в Redmine в этот день после
+отправки, не теряются.
+
+Повторный запуск `--commit`/`--send` в тот же день даёт окно
+«сегодня--сегодня», которое повторно включает уже отправленные записи этого
+дня.
+
+Важно: `--commit`/`--send` перезаписывают только `period.from`; остальные
+ключи YAML сохраняются, но пользовательские комментарии теряются
+(перезапись через `yaml.dump`).
+
+## Справочник флагов
+
+| Флаг | Описание |
+| --- | --- |
+| `--date` | Явный диапазон: границы — дата `YYYY-MM-DD` или datetime `YYYY-MM-DDTHH:MM:SS`. Время отбрасывается (полные дни), границы можно смешивать; `start > end` — ошибка. |
+| `--compact` | Компактный текстовый вывод в консоль вместо таблицы. |
+| `--output` | Путь к файлу (`.odt`/`.csv`/`.md`/`.html`/`.json`/`.xlsx`) или bare-формат — тогда путь берётся из YAML-шаблона; без флага — вывод в консоль (stdout). |
+| `--author` | Переопределить имя автора отчёта. |
+| `--no-time` | Не включать затраченное время в отчёт. |
+| `--url` | Переопределить URL Redmine. |
+| `--api-key` | Переопределить API-ключ Redmine. |
+| `--config` | Путь к альтернативному `.env`-файлу. |
+| `--verbose` | Подробный вывод; показывает traceback при ошибках. |
+| `--debug` | Отладочный вывод; показывает traceback при ошибках. |
+| `--version` | Показать версию и выйти. |
+| `--summary` | Сводка по времени в stderr: `total`, `project:*`, `activity:*` (версии не печатаются). |
+| `--user-id` | Отчёт за пользователя по ID. |
+| `--user-login` | Отчёт за пользователя по логину (точное регистрозависимое совпадение). |
+| `--user-name` | Отчёт за пользователя по имени. |
+| `--by-activity` | Разбивка времени по типам активности (в JSON — поле `activities`). |
+| `--init-config` | Сгенерировать YAML-конфиг из текущего `.env`/окружения и выйти. |
+| `--force` | Перезаписать существующий YAML-конфиг (только с `--init-config`). |
+| `--config-path` | Путь к YAML-конфигу: загрузка, запись `--init-config` и `--commit`. По умолчанию `~/.config/redmine-reporter/config.yml`. |
+| `--commit` | Сохранить отчёт в файл и сдвинуть начало периода (`period.from` = конец окна) в YAML. |
+| `--send` | Отправить отчёт по email после сохранения файла; при подтверждении и успехе сдвинуть начало периода. |
+| `--my-tasks` | Вместо отчёта вывести открытые задачи, назначенные на вас (или на пользователя из `--user-id`/`--user-login`/`--user-name`): таблица с сортировкой по срочности + сводка в stderr. Несовместим с `--date`, `--output`, `--compact`, `--summary`, `--no-time`, `--by-activity`, `--commit`, `--send`. Подробнее: [Список открытых задач](#список-открытых-задач). |
+
+## Устранение неполадок
+
+| Ошибка | Причина | Решение |
+| --- | --- | --- |
+| «REDMINE_URL must use HTTPS...» (exit 1) | URL Redmine не по HTTPS | Укажите `https://` в `redmine.url` / `REDMINE_URL` / `--url`. |
+| «Authentication failed: invalid API key, login or password. Check REDMINE_API_KEY / REDMINE_USER / REDMINE_PASSWORD.» | Неверный или отсутствующий API-ключ, логин или пароль | Проверьте `redmine.api_key` / `--api-key` (или `REDMINE_USER` / `REDMINE_PASSWORD`). |
+| «User '...' not found...» | Пользователь не найден ни по ID, ни по логину, ни по имени | Проверьте написание; логин сравнивается точно с учётом регистра. |
+| «Multiple users match...» | По имени найдено несколько пользователей (или несколько дублей логина) | Используйте `--user-login` с логином из списка или уточните числовой ID для `--user-id`. |
+| Указано несколько `--user-*` | Флаги взаимоисключающие | Оставьте только один из `--user-id` / `--user-login` / `--user-name`. |
+| «--my-tasks cannot be used with report-generating flags.» (exit 1) | `--my-tasks` совмещён с отчётными флагами (`--date`, `--output`, `--compact`, `--summary`, `--no-time`, `--by-activity`, `--commit`, `--send`) | Запускайте режим отдельно: список задач и отчёт -- разные команды (см. [Список открытых задач](#список-открытых-задач)). |
+| «Неизвестный формат файла: '.xyz'. Поддерживаются: .odt, .csv, .md, .html, .json, .xlsx» (exit 1) | `--output` с неизвестным расширением | Используйте одно из поддерживаемых расширений. |
+| Ошибка про `odfpy` при `.odt` | Пакет `odfpy` не установлен | `pip install odfpy` или выберите другой формат. |
+| «Email не настроен. Добавьте секцию 'email' в конфиг...» (exit 1) | `--send` без секции `email` в YAML или с пустым `smtp.host` | Добавьте секцию `email` (см. [CONFIG.md](CONFIG.md)). |
+| «Ошибка аутентификации SMTP. Проверьте логин и пароль.» | Неверные `smtp.user`/`smtp.password` | Проверьте логин и пароль в конфиге. |
+| «Таймаут соединения с SMTP-сервером.» | Сервер не ответил за 30 секунд | Проверьте сеть, `smtp.host` и `smtp.port`. |
+| «Не удалось подключиться к SMTP-серверу host:port» | Нет соединения с SMTP | Проверьте `smtp.host`, `smtp.port` и доступность сервера. |
+| «Ошибка отправки письма: ...» | Прочая ошибка SMTP | Смотрите детали после двоеточия; файл отчёта уже сохранён на диске. |
+| Предупреждение о правах конфига при старте | Права `config.yml` шире `0600` | `chmod 600 ~/.config/redmine-reporter/config.yml`. |
+| Предупреждение о MITM при старте | `verify_ssl: false` / `REDMINE_VERIFY=false` — проверка TLS отключена | Включите проверку или используйте только в доверенной сети. |
+| «⚠️  Could not load version ...: Due date will be empty for its issues.» в режиме `--my-tasks` | Версия из списка задач недоступна (нет прав, удалена, сбой сети) | Некритично: срок этой версии останется пустым; проверьте права доступа к проекту версии. |
+| Не виден traceback при ошибке | Traceback показывается только с `--verbose`/`--debug` | Повторите запуск с `--debug`. |
+
+API-ключ в текстах ошибок маскируется (`***`).
+
+## См. также
+
+- [README.md](../README.md) — обзор, быстрый старт, форматы вывода.
+- [CONFIG.md](CONFIG.md) — полный референс конфигурации (YAML, env, приоритеты, безопасность).

pyproject.toml

@@ -4,20 +4,19 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "redmine-reporter"
-version = "1.10.1"
+version = "2.1.0"
 description = "Redmine time-entry based issue reporter for internal use"
 readme = "README.md"
 authors = [{ name = "Artem Kokos", email = "artem-kokos@mail.ru" }]
 license = { text = "MIT" }
 classifiers = [
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Operating System :: POSIX :: Linux",
     "Environment :: Console",
 ]
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 dependencies = [
     "python-redmine>=2.4.0",
     "tabulate>=0.9.0",
@@ -25,6 +24,9 @@ dependencies = [
     "odfpy>=1.4.0",
     "openpyxl>=3.1.0",
     "pyyaml>=6.0",
+    "requests>=2.31",
+    "truststore>=0.10",
+    "urllib3>=1.26",
 ]
 
 [project.optional-dependencies]
@@ -32,6 +34,9 @@ dev = [
     "pytest>=7.0",
     "mypy>=1.0",
     "ruff>=0.1.0",
+    "black>=24.0",
+    "isort>=5.0",
+    "setuptools>=61.0",
 ]
 
 [project.scripts]
@@ -44,9 +49,19 @@ include = ["redmine_reporter*"]
 [tool.setuptools.package-data]
 "redmine_reporter" = ["templates/template.odt"]
 
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["."]
+
 [tool.mypy]
 warn_unused_configs = true
 
 [[tool.mypy.overrides]]
 module = ["odf.*", "redminelib.*", "tabulate", "openpyxl.*", "yaml", "requests", "urllib3.*"]
 ignore_missing_imports = true
+
+[tool.isort]
+profile = "black"
+
+[tool.ruff.lint.isort]
+known-first-party = ["redmine_reporter"]

redmine_reporter/__init__.py

@@ -1 +1 @@
-__version__ = "1.10.1"
+__version__ = "2.1.0"

redmine_reporter/cli.py

@@ -3,47 +3,93 @@ import logging
 import os
 import re
 import sys
-from datetime import datetime, timezone
+from datetime import datetime
 from pathlib import Path
-from typing import List, Optional
 
 import yaml
+from dotenv import find_dotenv, load_dotenv
 
 from . import __version__
-from .client import RedmineAPIError, fetch_issues_with_spent_time
+from .client import RedmineAPIError, fetch_issues_with_spent_time, fetch_open_issues
 from .config import Config
 from .formatters.factory import get_console_formatter, get_formatter_by_extension
+from .formatters.task_table import TaskTableFormatter
 from .mailer import send_report
 from .report_builder import build_grouped_report, calculate_summary
+from .task_list import (
+    build_task_rows,
+    calculate_task_summary,
+    filter_excluded_versions,
+    format_summary_line,
+)
 from .yaml_config import ensure_config_dir, resolve_output_path, save_period_to_config
 
+# Маскируем API-ключ Redmine в тексте ошибок (#55):
+#  - query-параметр key=<значение> в URL (?key=... / &key=...);
+#  - заголовок X-Redmine-API-Key: <значение>.
+_SANITIZE_PATTERNS = [
+    (re.compile(r"([?&]key=)[^\s&\"')]+", re.IGNORECASE), r"\1***"),
+    (
+        re.compile(
+            r"(X-Redmine-API-Key[\"']?\s*[:=]\s*[\"']?)[^\s\"',}]+", re.IGNORECASE
+        ),
+        r"\1***",
+    ),
+]
+
+
+def _sanitize_error_text(text: str) -> str:
+    """Маскирует API-ключ Redmine в тексте ошибки перед выводом в stderr (#55)."""
+    for pattern, replacement in _SANITIZE_PATTERNS:
+        text = pattern.sub(replacement, text)
+    return text
+
+
+def _parse_boundary(value: str) -> datetime:
+    """Разбирает одну границу диапазона как дату или datetime без timezone."""
+    if re.fullmatch(r"\d{4}-\d{2}-\d{2}", value):
+        fmt = "%Y-%m-%d"
+    elif re.fullmatch(r"\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}", value):
+        fmt = "%Y-%m-%dT%H:%M:%S"
+    else:
+        raise ValueError("Date range must be in format YYYY-MM-DD--YYYY-MM-DD")
+    try:
+        return datetime.strptime(value, fmt)
+    except ValueError as e:
+        raise ValueError("Date range contains invalid calendar date") from e
+
 
 def parse_date_range(date_arg: str) -> tuple[str, str]:
+    """Возвращает границы диапазона в виде дат YYYY-MM-DD.
+
+    Каждая граница может быть датой или datetime; время отбрасывается
+    (границы окна -- целые дни), поэтому смешение форматов допустимо.
+    """
     if "--" not in date_arg:
         raise ValueError("Date range must be in format YYYY-MM-DD--YYYY-MM-DD")
     parts = date_arg.split("--", 1)
 
     from_date, to_date = parts[0].strip(), parts[1].strip()
-    date_pattern = r"\d{4}-\d{2}-\d{2}"
-    if not re.fullmatch(date_pattern, from_date) or not re.fullmatch(
-        date_pattern, to_date
-    ):
-        raise ValueError("Date range must be in format YYYY-MM-DD--YYYY-MM-DD")
+    start = _parse_boundary(from_date)
+    end = _parse_boundary(to_date)
 
-    try:
-        start = datetime.strptime(from_date, "%Y-%m-%d").date()
-        end = datetime.strptime(to_date, "%Y-%m-%d").date()
-    except ValueError as e:
-        raise ValueError("Date range contains invalid calendar date") from e
-
-    if start > end:
+    if start.date() > end.date():
         raise ValueError("Date range start must be less than or equal to end")
 
-    return start.isoformat(), end.isoformat()
+    return start.date().isoformat(), end.date().isoformat()
 
 
 def _run_init_config(config_path: str, force: bool) -> int:
-    """Создаёт YAML-конфиг из текущих настроек окружения."""
+    """Создаёт YAML-конфиг из текущих настроек окружения.
+
+    Подгружает .env из текущей директории (override=False: реальные
+    переменные окружения не перебиваются), чтобы --init-config видел
+    значения, заданные только в .env (#64). Поиск идёт от cwd
+    (usecwd=True): find_dotenv() без него стартует от директории
+    cli.py и .env пользователя не находит.
+    """
+    load_dotenv(find_dotenv(usecwd=True), override=False)
+
     path = Path(config_path)
 
     if path.exists() and not force:
@@ -62,10 +108,7 @@ def _run_init_config(config_path: str, force: bool) -> int:
             "verify_ssl": True,
         },
         "period": {
-            "precision": "date",
-            "default_from": os.getenv("DEFAULT_FROM_DATE", "").strip(),
-            "default_to": os.getenv("DEFAULT_TO_DATE", "").strip(),
-            "dynamic": False,
+            "from": os.getenv("FROM_DATE", "").strip(),
         },
         "output": {
             "dir": "",
@@ -99,6 +142,16 @@ def _run_init_config(config_path: str, force: bool) -> int:
         yaml.dump(
             data, fh, allow_unicode=True, default_flow_style=False, sort_keys=False
         )
+        fh.write(
+            "\n"
+            "# report.status_translation: переопределение/дополнение перевода\n"
+            "# статусов Redmine. Без секции используется встроенный словарь.\n"
+            "# Пример:\n"
+            "# report:\n"
+            "#   status_translation:\n"
+            '#     "New": "Новая"\n'
+            '#     "Wait Release": "Ожидает релиза"\n'
+        )
     path.chmod(0o600)
 
     sections_found = [s for s in data if data[s]]
@@ -108,29 +161,6 @@ def _run_init_config(config_path: str, force: bool) -> int:
     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 _resolve_no_time(cli_flag: bool, is_auto_mode: bool) -> bool:
     """Возвращает финальное значение no_time.
 
@@ -154,10 +184,11 @@ def _save_and_maybe_send(
     to_date: str,
     no_time: bool,
     do_send: bool,
-) -> int:
+) -> tuple[int, bool]:
     """Сохраняет отчёт в файл и опционально отправляет по email.
 
-    Returns 0 on success, 1 on error.
+    Returns (exit_code, sent): sent отражает факт реальной отправки письма,
+    чтобы main мог отличить отказ от подтверждения от успешной отправки.
     """
     output_ext = os.path.splitext(output_arg)[1].lower()
 
@@ -166,7 +197,7 @@ def _save_and_maybe_send(
             "❌ Файл без расширения. Укажите расширение: .odt, .csv, .md, .html, .json или .xlsx",
             file=sys.stderr,
         )
-        return 1
+        return 1, False
 
     formatter = get_formatter_by_extension(
         output_ext,
@@ -183,21 +214,20 @@ def _save_and_maybe_send(
                 file=sys.stderr,
             )
         else:
-            known_exts = ", ".join([".odt", ".csv", ".md", ".html", ".json", ".xlsx"])
             print(
                 f"❌ Неизвестный формат файла: {output_ext!r}. "
-                f"Поддерживаются: {known_exts}",
+                "Поддерживаются: .odt, .csv, .md, .html, .json, .xlsx",
                 file=sys.stderr,
             )
-        return 1
+        return 1, False
 
     try:
         formatter.save(rows, output_arg)
         print(f"✅ Report saved to {output_arg}")
-    except Exception as e:
+    except Exception as e:  # noqa: BLE001 -- форматёры (odfpy/openpyxl/csv) бросают произвольные типы, CLI обязан вернуть код 1 на любой сбой
         fmt = output_ext.lstrip(".").upper()
         print(f"❌ {fmt} export error: {e}", file=sys.stderr)
-        return 1
+        return 1, False
 
     if do_send:
         email_config = Config.get_email_config()
@@ -207,7 +237,20 @@ def _save_and_maybe_send(
                 "(~/.config/redmine-reporter/config.yml).",
                 file=sys.stderr,
             )
-            return 1
+            return 1, False
+
+        print("\n📧 Готово к отправке:")
+        print(f"   From: {email_config.from_}")
+        print(f"   To:   {', '.join(email_config.to)}")
+        if email_config.cc:
+            print(f"   Cc:   {', '.join(email_config.cc)}")
+        if email_config.bcc:
+            print(f"   Bcc:  {', '.join(email_config.bcc)}")
+        print(f"   File: {output_arg}")
+        response = input("Отправить? [y/N]: ").strip().lower()
+        if response not in ("y", "yes"):
+            print("⏭️  Отправка отменена.")
+            return 0, False
 
         try:
             send_report(
@@ -219,13 +262,58 @@ def _save_and_maybe_send(
             )
             print(f"📧 Report sent to {', '.join(email_config.to)}")
         except RedmineAPIError as e:
-            print(f"❌ {e.message}", file=sys.stderr)
+            print(f"❌ {_sanitize_error_text(e.message)}", file=sys.stderr)
+            return 1, False
+        return 0, True
+
+    return 0, False
+
+
+def _run_my_tasks(args: argparse.Namespace) -> int:
+    """Режим --my-tasks: таблица открытых задач пользователя в stdout (#71).
+
+    Саммари печатается в stderr, а не в stdout: при перенаправлении вывода
+    в файл остаётся только таблица без служебных строк.
+    """
+    try:
+        items = fetch_open_issues(
+            user_id=args.user_id or args.user_login or args.user_name
+        )
+    except RedmineAPIError as e:
+        print(f"❌ {_sanitize_error_text(e.message)}", file=sys.stderr)
+        if (args.verbose or args.debug) and e.original is not None:
+            # Точка входа CLI: root-логгер осознанно настроен через basicConfig
+            # в main(), module-логгер здесь дал бы второй набор хендлеров.
+            logging.exception("Original Redmine API error")  # noqa: LOG015
+        return 1
+    except Exception as e:
+        print(f"❌ Unexpected error: {_sanitize_error_text(str(e))}", file=sys.stderr)
+        if args.verbose or args.debug:
+            logging.exception("Unexpected error")  # noqa: LOG015
         return 1
 
+    # Бакет-версии (Wishlist) исключаются до проверки на пустоту: если все
+    # открытые задачи в них, пользователь видит "Открытых задач нет".
+    items = filter_excluded_versions(items)
+
+    if not items:
+        print("ℹ️  Открытых задач нет.", file=sys.stderr)
+        return 0
+
+    rows = build_task_rows(items, Config.get_status_translation())
+    summary = calculate_task_summary(items)
+    print(format_summary_line(summary), file=sys.stderr)
+    print(file=sys.stderr)
+    try:
+        table = TaskTableFormatter(base_url=Config.get_redmine_url()).format(rows)
+    except Exception as e:  # noqa: BLE001 -- сбой рендера таблицы не должен ронять CLI трейсбеком: печатаем ошибку и возвращаем код 1
+        print(f"❌ Formatting error: {e}", file=sys.stderr)
+        return 1
+    print(table)
     return 0
 
 
-def main(argv: Optional[List[str]] = None) -> int:
+def main(argv: list[str] | None = None) -> int:
     parser = argparse.ArgumentParser(
         prog="redmine-reporter",
         description="Generate Redmine issue report based on your time entries.",
@@ -303,12 +391,17 @@ def main(argv: Optional[List[str]] = None) -> int:
     parser.add_argument(
         "--commit",
         action="store_true",
-        help="Save used period as last_used in YAML config and auto-commit to file",
+        help="Save the report and advance period start to its end date in YAML config",
     )
     parser.add_argument(
         "--send",
         action="store_true",
-        help="Send generated report via email after saving (requires email section in config)",
+        help="Send generated report via email after saving (requires email section in config); on success advance period start to its end date",
+    )
+    parser.add_argument(
+        "--my-tasks",
+        action="store_true",
+        help="List open issues assigned to you, sorted by urgency, and exit",
     )
     args = parser.parse_args(argv)
 
@@ -335,6 +428,25 @@ def main(argv: Optional[List[str]] = None) -> int:
             return 1
         return _run_init_config(args.config_path, args.force)
 
+    # --my-tasks: отдельный режим, отчётное окно и файлы к нему неприменимы
+    if args.my_tasks:
+        report_flags = [
+            args.date is not None,
+            args.output,
+            args.compact,
+            args.summary,
+            args.no_time,
+            args.by_activity,
+            args.commit,
+            args.send,
+        ]
+        if any(report_flags):
+            print(
+                "❌ --my-tasks cannot be used with report-generating flags.",
+                file=sys.stderr,
+            )
+            return 1
+
     # Валидация взаимоисключающих флагов пользователя
     user_args = [args.user_id, args.user_login, args.user_name]
     if sum(bool(a) for a in user_args) > 1:
@@ -368,6 +480,10 @@ def main(argv: Optional[List[str]] = None) -> int:
         print(f"❌ Configuration error: {e}", file=sys.stderr)
         return 1
 
+    # Ветка --my-tasks: даты отчётного окна режиму не нужны.
+    if args.my_tasks:
+        return _run_my_tasks(args)
+
     # Если --date не указан, используем дефолтный диапазон
     date_arg = args.date if args.date is not None else Config.get_default_date_range()
     try:
@@ -382,21 +498,20 @@ def main(argv: Optional[List[str]] = None) -> int:
             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)
-        if args.debug and e.original is not None:
-            logging.exception("Original Redmine API error")
+        print(f"❌ {_sanitize_error_text(e.message)}", file=sys.stderr)
+        if (args.verbose or args.debug) and e.original is not None:
+            # Точка входа CLI: root-логгер осознанно настроен через basicConfig
+            # в main(), module-логгер здесь дал бы второй набор хендлеров.
+            logging.exception("Original Redmine API error")  # noqa: LOG015
         return 1
     except Exception as e:
-        print(f"❌ Unexpected error: {e}", file=sys.stderr)
+        print(f"❌ Unexpected error: {_sanitize_error_text(str(e))}", file=sys.stderr)
+        if args.verbose or args.debug:
+            logging.exception("Unexpected error")  # noqa: LOG015
         return 1
 
-    if issue_hours is None:
-        print("ℹ️  No time entries found in the given period.", file=sys.stderr)
-        return 0
-
     if not issue_hours:
         print("ℹ️  No time entries found in the given period.", file=sys.stderr)
         return 0
@@ -410,6 +525,7 @@ def main(argv: Optional[List[str]] = None) -> int:
         issue_hours,
         fill_time=not no_time,
         by_activity=args.by_activity,
+        status_translation=Config.get_status_translation(),
     )
 
     if args.summary:
@@ -426,6 +542,9 @@ def main(argv: Optional[List[str]] = None) -> int:
                 activity = key.split(":", 1)[1]
                 print(f"   [{activity}]: {value}h", file=sys.stderr)
 
+    save_ok = False
+    report_sent = False
+
     if args.output or args.commit:
         if args.output:
             output_arg = resolve_output_path(
@@ -456,7 +575,7 @@ def main(argv: Optional[List[str]] = None) -> int:
             )
             return 1
 
-        ret = _save_and_maybe_send(
+        ret, report_sent = _save_and_maybe_send(
             rows,
             output_arg,
             author=Config.get_author(args.author),
@@ -467,6 +586,7 @@ def main(argv: Optional[List[str]] = None) -> int:
         )
         if ret != 0:
             return ret
+        save_ok = True
 
     elif args.send:
         # --send без --output и --commit: сохраняем по шаблону и отправляем
@@ -487,7 +607,7 @@ def main(argv: Optional[List[str]] = None) -> int:
             )
             return 1
 
-        ret = _save_and_maybe_send(
+        ret, report_sent = _save_and_maybe_send(
             rows,
             output_arg,
             author=Config.get_author(args.author),
@@ -498,6 +618,7 @@ def main(argv: Optional[List[str]] = None) -> int:
         )
         if ret != 0:
             return ret
+        save_ok = True
 
     else:
         if args.compact:
@@ -512,36 +633,29 @@ def main(argv: Optional[List[str]] = None) -> int:
         try:
             output = formatter.format(rows)
             print(output)
-        except Exception as e:
+        except Exception as e:  # noqa: BLE001 -- консольный форматтер не должен ронять CLI: печатаем ошибку и возвращаем код 1
             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
+    # Окно двигается ровно один раз за запуск: либо по явному --commit
+    # (операция завершилась кодом 0), либо по фактически отправленному письму --send.
+    should_advance = (args.commit and save_ok) or (args.send and report_sent)
+    if should_advance:
+        # Начало следующего окна совпадает с концом текущего: граничный день
+        # перечитывается. Дубли записей дня коммита осознанны, зато поздние
+        # записи, добавленные в тот же день после отправки, не теряются.
+        next_from = to_date
 
         try:
-            save_period_to_config(
-                args.config_path, from_str, to_str, precision, dynamic
-            )
-        except Exception as e:
+            save_period_to_config(args.config_path, from_str=next_from)
+        except Exception as e:  # noqa: BLE001 -- сбой записи конфига не должен ронять CLI трейсбеком: сообщаем и возвращаем код 1
             print(
                 f"❌ Не удалось сохранить период в конфиг: {e}",
                 file=sys.stderr,
             )
             return 1
         print(
-            f"📌 Period committed [{from_str} -- {to_str}] → {args.config_path}",
+            f"📌 Period committed [{next_from}] → {args.config_path}",
             file=sys.stderr,
         )
 

redmine_reporter/client.py

@@ -1,7 +1,9 @@
-from datetime import datetime
-from typing import Any, Dict, List, Optional, Tuple, Union
+import sys
+from datetime import date
+from typing import Any
 
 import requests
+import truststore
 from redminelib import Redmine
 from redminelib.exceptions import AuthError, ForbiddenError, ResourceNotFoundError
 from redminelib.resources import Issue
@@ -19,13 +21,13 @@ ISSUE_ID_CHUNK_SIZE = 100
 class RedmineAPIError(Exception):
     """Пользовательское исключение с понятным сообщением об ошибке Redmine API."""
 
-    def __init__(self, message: str, original: Optional[Exception] = None):
+    def __init__(self, message: str, original: Exception | None = None):
         super().__init__(message)
         self.message = message
         self.original = original
 
 
-def _get_redmine_auth_kwargs() -> Dict[str, Any]:
+def _get_redmine_auth_kwargs() -> dict[str, Any]:
     """Return Redmine auth kwargs. API key has priority over legacy password auth."""
     api_key = Config.get_redmine_api_key()
     if api_key:
@@ -48,12 +50,21 @@ def _make_retry_adapter() -> requests.adapters.HTTPAdapter:
 
 
 def _create_redmine() -> Redmine:
-    """Создаёт Redmine-клиент с таймаутом и retry-адаптером (#24)."""
+    """Создаёт Redmine-клиент с таймаутом и retry-адаптером (#24).
+
+    При verify=True подключает системное хранилище CA ОС через
+    truststore.inject_into_ssl() (#62).
+    """
+    verify = Config.get_redmine_verify()
+    if verify is True:
+        # verify_ssl: true — проверка по системному хранилищу CA ОС (truststore),
+        # а не по certifi: корпоративные CA из ОС продолжают работать (#62).
+        truststore.inject_into_ssl()
     redmine = Redmine(
         Config.get_redmine_url(),
         **_get_redmine_auth_kwargs(),
         requests={
-            "verify": Config.get_redmine_verify(),
+            "verify": verify,
             "timeout": REQUEST_TIMEOUT,
         },
     )
@@ -112,7 +123,7 @@ def _format_redmine_error(exc: Exception) -> str:
     return str(exc)
 
 
-def _load_time_entry_activities(redmine: Redmine) -> Dict[int, str]:
+def _load_time_entry_activities(redmine: Redmine) -> dict[int, str]:
     """Загружает справочник типов активности time entries.
 
     Возвращает словарь id -> name. Если справочник недоступен,
@@ -121,11 +132,18 @@ def _load_time_entry_activities(redmine: Redmine) -> Dict[int, str]:
     try:
         activities = redmine.enumeration.filter(resource="time_entry_activities")
         return {int(a.id): str(a.name) for a in activities}
-    except Exception:
+    except Exception as exc:  # noqa: BLE001 -- python-redmine бросает разные типы; справочник не критичен, деградируем к данным из entries
+        # #61: не глотаем сбой молча — предупреждаем, что разбивка по
+        # активностям будет построена по сырым данным из самих entries.
+        print(
+            f"⚠️  Could not load time entry activities: {exc}. "
+            "Activity names will be taken from time entries.",
+            file=sys.stderr,
+        )
         return {}
 
 
-def _get_activity_name(entry, activities: Dict[int, str]) -> str:
+def _get_activity_name(entry, activities: dict[int, str]) -> str:
     """Определяет название активности для time entry."""
     activity = getattr(entry, "activity", None)
     if activity is None:
@@ -145,28 +163,9 @@ def _get_activity_name(entry, activities: Dict[int, str]) -> str:
     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]:
+def _fetch_issues_chunked(redmine: Redmine, issue_ids: list[int]) -> list[Issue]:
     """Загружает задачи чанками, чтобы не превышать лимит длины URL (#21)."""
-    all_issues: List[Issue] = []
+    all_issues: list[Issue] = []
     for i in range(0, len(issue_ids), ISSUE_ID_CHUNK_SIZE):
         chunk = issue_ids[i : i + ISSUE_ID_CHUNK_SIZE]
         issue_list_str = ",".join(str(x) for x in chunk)
@@ -177,7 +176,7 @@ def _fetch_issues_chunked(redmine: Redmine, issue_ids: List[int]) -> List[Issue]
     return all_issues
 
 
-def _resolve_user_id(redmine: Redmine, user_arg: Union[int, str]) -> int:
+def _resolve_user_id(redmine: Redmine, user_arg: int | str) -> int:
     """Преобразует строковый идентификатор пользователя в числовой ID.
 
     Если аргумент — число, возвращает его как есть.
@@ -197,8 +196,18 @@ def _resolve_user_id(redmine: Redmine, user_arg: Union[int, str]) -> int:
     # Затем ищем по логину
     try:
         users = redmine.user.filter(login=text)
-        if users:
-            return int(users[0].id)
+        # Фильтр Redmine по логину неточный (substring-поиск), поэтому
+        # выбираем только точные регистрозависимые совпадения логина (#60).
+        exact_matches = [u for u in users if getattr(u, "login", None) == text]
+        if len(exact_matches) == 1:
+            return int(exact_matches[0].id)
+        if len(exact_matches) > 1:
+            matches = ", ".join(str(u.id) for u in exact_matches[:5])
+            raise RedmineAPIError(
+                f"Multiple users match '{text}': {matches}. Use --user-id with numeric ID."
+            )
+    except RedmineAPIError:
+        raise
     except Exception as exc:
         raise RedmineAPIError(
             f"Cannot resolve user login '{text}': {_format_redmine_error(exc)}",
@@ -240,17 +249,14 @@ def _get_current_user_id(redmine: Redmine) -> int:
 def fetch_issues_with_spent_time(
     from_date: str,
     to_date: str,
-    user_id: Optional[Union[int, str]] = None,
+    user_id: int | str | None = None,
     by_activity: bool = False,
-    dedup_before: Optional[datetime] = None,
-) -> Optional[List[Tuple[Issue, float, Optional[Dict[str, float]]]]]:
+) -> list[tuple[Issue, float, dict[str, float] | None]] | None:
     """
     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.
     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.
     """
@@ -265,7 +271,9 @@ def fetch_issues_with_spent_time(
         activities_lookup = _load_time_entry_activities(redmine) if by_activity else {}
         time_entries = list(
             redmine.time_entry.filter(
-                user_id=target_user_id, from_date=from_date, to_date=to_date
+                user_id=target_user_id,
+                from_date=from_date,
+                to_date=to_date,
             )
         )
     except RedmineAPIError:
@@ -273,29 +281,9 @@ def fetch_issues_with_spent_time(
     except Exception as exc:
         raise RedmineAPIError(_format_redmine_error(exc), original=exc) from exc
 
-    # Дедупликация: отсекаем записи, которые были учтены в предыдущем отчёте.
-    # Запись исключается, если 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]] = {}
+    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"):
@@ -319,6 +307,20 @@ def fetch_issues_with_spent_time(
     except Exception as exc:
         raise RedmineAPIError(_format_redmine_error(exc), original=exc) from exc
 
+    # #61: задачи могли не вернуться из issue.filter (нет прав / удалены) —
+    # предупреждаем о выпавших задачах и потерянных часах, но строим отчёт
+    # по доступным данным.
+    returned_ids = {issue.id for issue in issues}
+    missing_ids = sorted(issue_ids - returned_ids)
+    if missing_ids:
+        lost_hours = sum(spent_time[iid] for iid in missing_ids)
+        print(
+            f"⚠️  {len(missing_ids)} issue(s) unavailable (no access or deleted; "
+            f"IDs: {', '.join(str(i) for i in missing_ids)}): "
+            f"{lost_hours:g}h excluded from the report.",
+            file=sys.stderr,
+        )
+
     # Сопоставляем задачи с суммарным временем.
     # Сортировка выполняется в report_builder.build_grouped_report,
     # здесь оставляем порядок API как есть.
@@ -332,3 +334,66 @@ def fetch_issues_with_spent_time(
         result.append((issue, total_hours, activity_breakdown))
 
     return result
+
+
+def fetch_open_issues(
+    user_id: int | str | None = None,
+) -> list[tuple[Issue, date | None]]:
+    """
+    Fetch open issues assigned to the given user across all projects,
+    paired with the due date of each issue's fixed version.
+    If user_id is None, uses current user.
+    Returns list of (issue, due_date) tuples in API order; sorting is done
+    in the builder layer. Raises RedmineAPIError on API/auth/network failures.
+    """
+
+    try:
+        redmine = _create_redmine()
+        target_user_id = (
+            _resolve_user_id(redmine, user_id)
+            if user_id is not None
+            else _get_current_user_id(redmine)
+        )
+        # Без limit: python-redmine автопагинацией вычитывает все страницы,
+        # как в time_entry.filter выше.
+        issues = list(
+            redmine.issue.filter(assigned_to_id=target_user_id, status_id="open")
+        )
+    except RedmineAPIError:
+        raise
+    except Exception as exc:
+        raise RedmineAPIError(_format_redmine_error(exc), original=exc) from exc
+
+    # fixed_version внутри задачи содержит только id/name, поэтому due_date
+    # приходится добирать отдельным запросом на каждую уникальную версию (#71).
+    # Отказ загрузки одной версии не валидует выгрузку: её задачи получат None.
+    due_by_version: dict[int, date | None] = {}
+    for issue in issues:
+        version_ref = getattr(issue, "fixed_version", None)
+        if version_ref is None:
+            continue
+        version_id = getattr(version_ref, "id", None)
+        if version_id is None or version_id in due_by_version:
+            continue
+        try:
+            version = redmine.version.get(version_id)
+        except Exception as exc:  # noqa: BLE001 -- отказ загрузки одной версии не валидует выгрузку, деградируем к due_date=None
+            print(
+                f"⚠️  Could not load version {version_id}: {exc}. "
+                "Due date will be empty for its issues.",
+                file=sys.stderr,
+            )
+            due_by_version[version_id] = None
+        else:
+            due_by_version[version_id] = getattr(version, "due_date", None)
+
+    # Порядок задач сохраняем как в ответе API.
+    result: list[tuple[Issue, date | None]] = []
+    for issue in issues:
+        version_ref = getattr(issue, "fixed_version", None)
+        version_id = (
+            getattr(version_ref, "id", None) if version_ref is not None else None
+        )
+        due = due_by_version.get(version_id) if version_id is not None else None
+        result.append((issue, due))
+    return result

redmine_reporter/config.py

@@ -1,20 +1,18 @@
 import logging
 import os
+import sys
 from dataclasses import dataclass, field
-from datetime import date, timedelta
+from datetime import date
 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"
+DEFAULT_REDMINE_VERIFY: bool | str = True
 FALSE_VALUES = {"0", "false", "no", "off"}
 TRUE_VALUES = {"1", "true", "yes", "on"}
 
@@ -41,32 +39,22 @@ class EmailConfig:
     html: bool = False
 
 
-@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 = ""
+    redmine_verify: bool | str = DEFAULT_REDMINE_VERIFY
+    period_from: str = ""
     output_dir: str = ""
     output_filename: str = "{author}_{from}_{to}.{ext}"
     output_default_format: str = "xlsx"
     report_no_time: bool = False
+    report_status_translation: dict[str, str] = field(default_factory=dict)
     email: EmailConfig = field(default_factory=EmailConfig)
 
     @classmethod
-    def from_yaml(cls, path: Union[str, Path]) -> "AppConfig":
+    def from_yaml(cls, path: str | Path) -> "AppConfig":
         """Загружает настройки из YAML-файла.
 
         Если файл не существует — возвращает конфиг со значениями по умолчанию.
@@ -100,32 +88,19 @@ class AppConfig:
             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"),
+            period_from=cls._resolve_str(raw, "period", "from"),
             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",
             report_no_time=cls._resolve_bool(raw, "report", "no_time"),
+            report_status_translation=cls._resolve_str_dict(
+                raw, "report", "status_translation"
+            ),
             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)
@@ -141,6 +116,43 @@ class AppConfig:
             return ""
         return str(value)
 
+    @staticmethod
+    def _resolve_str_dict(raw: dict, section: str, key: str) -> dict[str, str]:
+        """Читает вложенный mapping строк из YAML-секции.
+
+        Не-mapping значение логируется с warning и игнорируется.
+        Ключи и значения приводятся к str, ${VAR} в значениях резолвится.
+        Записи со значением null или не-scalar (dict/list) пропускаются
+        с warning — иначе null стал бы строкой "None", а dict — repr.
+        """
+        section_value = raw.get(section)
+        if not isinstance(section_value, dict):
+            return {}
+        value = section_value.get(key)
+        if value is None:
+            return {}
+        if not isinstance(value, dict):
+            logger.warning(
+                "Config %s.%s must be a mapping, got %s — ignoring",
+                section,
+                key,
+                type(value).__name__,
+            )
+            return {}
+        result: dict[str, str] = {}
+        for k, v in value.items():
+            if v is None or isinstance(v, (dict, list)):
+                logger.warning(
+                    "Config %s.%s entry %r must be a scalar, got %s — skipping",
+                    section,
+                    key,
+                    k,
+                    type(v).__name__,
+                )
+                continue
+            result[str(k)] = resolve_env_vars(str(v))
+        return result
+
     @staticmethod
     def _resolve_bool(raw: dict, section: str, key: str) -> bool:
         value = raw.get(section, {}).get(key)
@@ -155,18 +167,24 @@ class AppConfig:
         return False
 
     @classmethod
-    def _resolve_verify(cls, raw: dict) -> Union[bool, str]:
+    def _resolve_verify(cls, raw: dict) -> bool | str:
+        """Семантика verify_ssl, единая с REDMINE_VERIFY из env:
+
+        - true (bool или строка) → True — стандартная проверка TLS (requests);
+        - false (bool или строка) → False — проверка отключена;
+        - любая другая строка → путь к CA-bundle как есть.
+        """
         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
+            return value
         if isinstance(value, str):
             normalized = value.lower()
             if normalized in FALSE_VALUES:
                 return False
             if normalized in TRUE_VALUES:
-                return DEFAULT_REDMINE_VERIFY
+                return True
             return resolve_env_vars(value)
         return DEFAULT_REDMINE_VERIFY
 
@@ -242,7 +260,13 @@ class Config:
 
     @classmethod
     def load_yaml(cls, path: str) -> None:
-        """Загружает YAML-конфиг. Не бросает исключений при отсутствии файла."""
+        """Загружает конфигурацию приложения.
+
+        Сначала подгружает .env из текущей директории (override=False:
+        переменные окружения не перебиваются), затем читает YAML-конфиг.
+        Не бросает исключений при отсутствии файла.
+        """
+        load_dotenv(override=False)
         cls._app = AppConfig.from_yaml(path)
 
     @classmethod
@@ -289,7 +313,7 @@ class Config:
         return os.getenv("REDMINE_PASSWORD", "").strip()
 
     @classmethod
-    def get_redmine_verify(cls) -> Union[bool, str]:
+    def get_redmine_verify(cls) -> bool | str:
         value = os.getenv("REDMINE_VERIFY", "").strip()
         if value:
             normalized = value.lower()
@@ -313,24 +337,6 @@ class Config:
             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:
@@ -356,6 +362,18 @@ class Config:
             return cls._app.report_no_time
         return False
 
+    @classmethod
+    def get_status_translation(cls) -> dict[str, str]:
+        """Полный словарь перевода статусов: встроенный + переопределения из YAML.
+
+        Возвращает новый словарь — модульный STATUS_TRANSLATION не мутируется.
+        Импорт ленивый: config.py не должен тянуть redminelib при импорте.
+        """
+        from .report_builder import STATUS_TRANSLATION
+
+        overrides = cls._app.report_status_translation if cls._app else {}
+        return {**STATUS_TRANSLATION, **overrides}
+
     @classmethod
     def get_email_config(cls) -> "EmailConfig | None":
         """Возвращает EmailConfig из YAML-конфига или None, если не настроен."""
@@ -368,90 +386,55 @@ class Config:
 
     @classmethod
     def get_default_date_range(cls) -> str:
-        from_env = os.getenv("DEFAULT_FROM_DATE", "").strip()
-        to_env = os.getenv("DEFAULT_TO_DATE", "").strip()
+        """Окно отчёта по умолчанию: from..сегодня.
+
+        Приоритет начала: env FROM_DATE -> YAML period.from -> 1-е число
+        текущего месяца. Некорректная дата не роняет CLI -- логируется
+        warning и берётся текущий месяц.
+        """
         today = date.today()
-        today_str = today.isoformat()
+        raw_from = os.getenv("FROM_DATE", "").strip()
+        if not raw_from and cls._app:
+            raw_from = cls._app.period_from
 
-        if from_env:
-            return f"{from_env}--{to_env or today_str}"
-
-        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",
+        if raw_from:
+            try:
+                start = date.fromisoformat(raw_from)
+            except (ValueError, TypeError):
+                logger.warning(
+                    "Invalid FROM_DATE/period.from %r -- expected ISO date "
+                    "(YYYY-MM-DD); using current month",
+                    raw_from,
                 )
-            return f"{nf}--{nt}"
-
-        if cls._app and cls._app.period_default_from:
-            default_to = cls._app.period_default_to or today_str
-            return f"{cls._app.period_default_from}--{default_to}"
-
                 start = today.replace(day=1)
-        return f"{start.isoformat()}--{today_str}"
+        else:
+            start = today.replace(day=1)
+
+        # Будущая start инвертирует диапазон и ломает фильтр Redmine,
+        # поэтому сжимаем окно до сегодняшнего дня.
+        start = min(start, today)
+        return f"{start.isoformat()}--{today.isoformat()}"
 
     @classmethod
     def validate(cls) -> None:
-        if not cls.get_redmine_url():
+        url = cls.get_redmine_url()
+        if not url:
             raise ValueError("REDMINE_URL is required (set via env or .env)")
+        if not url.lower().startswith("https://"):
+            raise ValueError(
+                "REDMINE_URL must use HTTPS: the API key is sent in request "
+                "headers and requires TLS"
+            )
+        if cls.get_redmine_verify() is False:
+            print(
+                "⚠️  TLS certificate verification is disabled "
+                "(REDMINE_VERIFY=false / verify_ssl: false): connection is "
+                "vulnerable to MITM attacks",
+                file=sys.stderr,
+            )
         if cls.get_redmine_api_key():
             return
         if not (cls.get_redmine_user() and cls.get_redmine_password()):
             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/base.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Any, List
+from typing import Any
 
 from ..types import ReportRow
 
@@ -16,19 +16,17 @@ class Formatter(ABC):
     """
 
     @abstractmethod
-    def format(self, rows: List[ReportRow]) -> Any:
+    def format(self, rows: list[ReportRow]) -> Any:
         """
         Форматирует список строк отчета в нужный формат.
         Для текстовых форматтеров возвращает str.
         Для ODTFormatter возвращает объект OpenDocument.
         """
-        pass
 
     @abstractmethod
-    def save(self, rows: List[ReportRow], output_path: str) -> None:
+    def save(self, rows: list[ReportRow], output_path: str) -> None:
         """
         Сохраняет отформатированный отчет в файл по указанному пути.
         Для форматтеров, которые не поддерживают сохранение (например, консольные),
         бросает NotImplementedError.
         """
-        pass

redmine_reporter/formatters/console.py

@@ -1,5 +1,3 @@
-from typing import List
-
 from tabulate import tabulate
 
 from ..types import ReportRow
@@ -9,7 +7,7 @@ from .base import Formatter
 class TableFormatter(Formatter):
     """Форматтер для вывода красивой таблицы в консоль."""
 
-    def format(self, rows: List[ReportRow]) -> str:
+    def format(self, rows: list[ReportRow]) -> str:
         table_rows = [["Проект", "Версия", "Задача", "Статус", "Затрачено"]]
         for r in rows:
             time_text = r["time_text"].replace("\n", " / ")
@@ -24,7 +22,7 @@ class TableFormatter(Formatter):
             )
         return tabulate(table_rows, headers="firstrow", tablefmt="fancy_grid")
 
-    def save(self, rows: List[ReportRow], output_path: str) -> None:
+    def save(self, rows: list[ReportRow], output_path: str) -> None:
         # Консольные форматтеры не умеют сохранять в файл напрямую.
         # Это делается в CLI.
         raise NotImplementedError("TableFormatter не поддерживает сохранение в файл.")
@@ -33,7 +31,7 @@ class TableFormatter(Formatter):
 class CompactFormatter(Formatter):
     """Форматтер для компактного вывода в консоль."""
 
-    def format(self, rows: List[ReportRow]) -> str:
+    def format(self, rows: list[ReportRow]) -> str:
         lines = []
         for r in rows:
             time_text = r["time_text"].replace("\n", " / ")
@@ -43,7 +41,7 @@ class CompactFormatter(Formatter):
             )
         return "\n".join(lines)
 
-    def save(self, rows: List[ReportRow], output_path: str) -> None:
+    def save(self, rows: list[ReportRow], output_path: str) -> None:
         # Консольные форматтеры не умеют сохранять в файл напрямую.
         # Это делается в CLI.
         raise NotImplementedError("CompactFormatter не поддерживает сохранение в файл.")

redmine_reporter/formatters/csv.py

@@ -1,6 +1,5 @@
 import csv
 import io
-from typing import List
 
 from ..types import ReportRow
 from .base import Formatter
@@ -19,7 +18,7 @@ class CSVFormatter(Formatter):
         super().__init__()
         self.no_time = no_time
 
-    def format(self, rows: List[ReportRow]) -> str:
+    def format(self, rows: list[ReportRow]) -> str:
         output = io.StringIO()
         writer = csv.writer(output, dialect="excel")
         headers = ["Project", "Version", "Issue ID", "Subject", "Status"]
@@ -40,7 +39,7 @@ class CSVFormatter(Formatter):
             writer.writerow(data)
         return output.getvalue()
 
-    def save(self, rows: List[ReportRow], output_path: str) -> None:
+    def save(self, rows: list[ReportRow], output_path: str) -> None:
         content = self.format(rows)
         with open(output_path, "w", encoding="utf-8-sig", newline="") as f:
             f.write(content)

redmine_reporter/formatters/factory.py

@@ -1,5 +1,3 @@
-from typing import Dict, Optional, Type
-
 from .base import Formatter
 from .console import CompactFormatter, TableFormatter
 from .csv import CSVFormatter
@@ -11,7 +9,7 @@ from .xlsx import XLSXFormatter
 # Словарь для сопоставления расширений файлов с классами форматтеров.
 # ODT и XLSX намеренно отсутствуют — их импорт отложен (ленивый), так как
 # odfpy/openpyxl может быть не установлен. См. get_formatter_by_extension.
-FORMATTER_MAP: Dict[str, Type[Formatter]] = {
+FORMATTER_MAP: dict[str, type[Formatter]] = {
     ".csv": CSVFormatter,
     ".json": JSONFormatter,
     ".md": MarkdownFormatter,
@@ -21,13 +19,13 @@ FORMATTER_MAP: Dict[str, Type[Formatter]] = {
 
 
 # Словарь для сопоставления типа вывода (консоль) с классами форматтеров
-CONSOLE_FORMATTER_MAP: Dict[str, Type[Formatter]] = {
+CONSOLE_FORMATTER_MAP: dict[str, type[Formatter]] = {
     "table": TableFormatter,
     "compact": CompactFormatter,
 }
 
 
-def get_formatter_by_extension(extension: str, **kwargs) -> Optional[Formatter]:
+def get_formatter_by_extension(extension: str, **kwargs) -> Formatter | None:
     """
     Возвращает экземпляр форматтера по расширению файла.
     Ключевые аргументы (**kwargs) передаются в конструктор форматтера.
@@ -51,7 +49,7 @@ def get_formatter_by_extension(extension: str, **kwargs) -> Optional[Formatter]:
     return None
 
 
-def get_console_formatter(formatter_type: str) -> Optional[Formatter]:
+def get_console_formatter(formatter_type: str) -> Formatter | None:
     """
     Возвращает экземпляр консольного форматтера по его типу.
     """

redmine_reporter/formatters/html.py

@@ -1,5 +1,4 @@
 from html import escape
-from typing import List
 
 from ..report_builder import group_rows_by_project_and_version
 from ..types import ReportRow
@@ -12,7 +11,7 @@ class HTMLFormatter(Formatter):
     def __init__(self, **_kwargs):
         super().__init__()
 
-    def format(self, rows: List[ReportRow]) -> str:
+    def format(self, rows: list[ReportRow]) -> str:
         projects = group_rows_by_project_and_version(rows)
 
         lines = [
@@ -79,7 +78,7 @@ class HTMLFormatter(Formatter):
         lines.append("</html>")
         return "\n".join(lines)
 
-    def save(self, rows: List[ReportRow], output_path: str) -> None:
+    def save(self, rows: list[ReportRow], output_path: str) -> None:
         content = self.format(rows)
         with open(output_path, "w", encoding="utf-8") as f:
             f.write(content)

redmine_reporter/formatters/json.py

@@ -1,5 +1,4 @@
 import json
-from typing import List
 
 from ..types import ReportRow
 from .base import Formatter
@@ -11,7 +10,7 @@ class JSONFormatter(Formatter):
     def __init__(self, **_kwargs):
         super().__init__()
 
-    def format(self, rows: List[ReportRow]) -> str:
+    def format(self, rows: list[ReportRow]) -> str:
         data = []
         for r in rows:
             item = {
@@ -28,7 +27,7 @@ class JSONFormatter(Formatter):
             data.append(item)
         return json.dumps(data, ensure_ascii=False, indent=2)
 
-    def save(self, rows: List[ReportRow], output_path: str) -> None:
+    def save(self, rows: list[ReportRow], output_path: str) -> None:
         content = self.format(rows)
         with open(output_path, "w", encoding="utf-8") as f:
             f.write(content)

redmine_reporter/formatters/markdown.py

@@ -1,5 +1,3 @@
-from typing import List
-
 from ..types import ReportRow
 from .base import Formatter
 
@@ -14,7 +12,7 @@ class MarkdownFormatter(Formatter):
     def __init__(self, **_kwargs):
         super().__init__()
 
-    def format(self, rows: List[ReportRow]) -> str:
+    def format(self, rows: list[ReportRow]) -> str:
         lines = [
             "| Проект | Версия | Задача | Статус | Затрачено |",
             "|--------|--------|--------|--------|-----------|",
@@ -30,7 +28,7 @@ class MarkdownFormatter(Formatter):
             )
         return "\n".join(lines)
 
-    def save(self, rows: List[ReportRow], output_path: str) -> None:
+    def save(self, rows: list[ReportRow], output_path: str) -> None:
         content = self.format(rows)
         with open(output_path, "w", encoding="utf-8") as f:
             f.write(content)

redmine_reporter/formatters/odt.py

@@ -1,5 +1,4 @@
 from importlib import resources
-from typing import List
 
 from odf.opendocument import OpenDocument, load
 from odf.style import Style, TableCellProperties, TableColumnProperties
@@ -25,7 +24,7 @@ class ODTFormatter(Formatter):
         self.from_date = from_date
         self.to_date = to_date
 
-    def format(self, rows: List[ReportRow]) -> OpenDocument:
+    def format(self, rows: list[ReportRow]) -> OpenDocument:
         """
         Форматирует данные в объект OpenDocument.
         """
@@ -172,7 +171,7 @@ class ODTFormatter(Formatter):
 
         return doc
 
-    def save(self, rows: List[ReportRow], output_path: str) -> None:
+    def save(self, rows: list[ReportRow], output_path: str) -> None:
         """
         Сохраняет сформированный документ в файл.
         """

redmine_reporter/formatters/task_table.py

@@ -0,0 +1,44 @@
+from tabulate import tabulate
+
+from ..types import TaskRow
+
+
+class TaskTableFormatter:
+    """Консольный форматтер таблицы открытых задач пользователя (режим --my-tasks).
+
+    Не входит в фабрику файловых форматтеров: таблица всегда печатается
+    в stdout, поэтому сохранение в файл не поддержано.
+    """
+
+    def __init__(self, base_url: str) -> None:
+        self.base_url = base_url
+
+    def _hyperlink(self, issue_id: int) -> str:
+        # OSC 8-гиперссылка: номер задачи остаётся видимым терминалом без
+        # поддержки ссылок, а поддерживающие делают его кликабельным.
+        url = f"{self.base_url.rstrip('/')}/issues/{issue_id}"
+        return f"\x1b]8;;{url}\x1b\\{issue_id}\x1b]8;;\x1b\\"
+
+    def format(self, rows: list[TaskRow]) -> str:
+        table_rows = [["ID", "Тема", "Статус", "Приор.", "Версия", "Срок"]]
+        for row in rows:
+            due_text = row["due_text"]
+            if row["overdue"]:
+                due_text = f"{due_text} (!)"
+            table_rows.append(
+                [
+                    self._hyperlink(row["issue_id"]),
+                    row["subject"],
+                    row["status_ru"],
+                    row["priority"],
+                    row["version_name"] or "-",
+                    due_text or "-",
+                ]
+            )
+        return tabulate(table_rows, headers="firstrow", tablefmt="simple")
+
+    def save(self, rows: list[TaskRow], output_path: str) -> None:
+        # Консольные форматтеры не умеют сохранять в файл напрямую.
+        raise NotImplementedError(
+            "TaskTableFormatter не поддерживает сохранение в файл."
+        )

redmine_reporter/formatters/xlsx.py

@@ -1,5 +1,3 @@
-from typing import Dict, List, Tuple
-
 from openpyxl import Workbook
 from openpyxl.styles import Alignment, Border, Font, PatternFill, Side
 from openpyxl.utils import get_column_letter
@@ -36,12 +34,9 @@ class XLSXFormatter(Formatter):
         super().__init__()
         self.no_time = no_time
 
-    def format(self, rows: List[ReportRow]) -> Workbook:
+    def format(self, rows: list[ReportRow]) -> Workbook:
         wb = Workbook()
         ws = wb.active
-        if ws is None:
-            ws = wb.create_sheet("Report")
-        else:
         ws.title = "Report"
 
         headers = [
@@ -59,9 +54,9 @@ class XLSXFormatter(Formatter):
         grouped = group_rows_by_project_and_version(rows)
 
         current_row = 2
-        project_ranges: List[Tuple[int, int]] = []
-        version_ranges: List[Tuple[int, int]] = []
-        project_totals: Dict[str, float] = {}
+        project_ranges: list[tuple[int, int]] = []
+        version_ranges: list[tuple[int, int]] = []
+        project_totals: dict[str, float] = {}
 
         for project, versions in grouped.items():
             project_start_row = current_row
@@ -178,11 +173,11 @@ class XLSXFormatter(Formatter):
 
         return wb
 
-    def save(self, rows: List[ReportRow], output_path: str) -> None:
+    def save(self, rows: list[ReportRow], output_path: str) -> None:
         wb = self.format(rows)
         wb.save(output_path)
 
-    def _style_header_row(self, ws: Worksheet, headers: List[str]) -> None:
+    def _style_header_row(self, ws: Worksheet, headers: list[str]) -> None:
         for col_idx, _ in enumerate(headers, start=1):
             cell = ws.cell(row=1, column=col_idx)
             cell.font = Font(bold=True)
@@ -196,9 +191,7 @@ class XLSXFormatter(Formatter):
         for col_idx in range(1, 8):
             cell = ws.cell(row=row, column=col_idx)
             cell.border = self._BORDER
-            if col_idx in (1, 2):
-                cell.alignment = Alignment(vertical="top", wrap_text=True)
-            elif col_idx == 4:
+            if col_idx in (1, 2) or col_idx == 4:
                 cell.alignment = Alignment(vertical="top", wrap_text=True)
             else:
                 cell.alignment = Alignment(vertical="top")
@@ -213,7 +206,7 @@ class XLSXFormatter(Formatter):
 
     def _apply_column_widths(self, ws: Worksheet) -> None:
         # Минимальные ширины по умолчанию
-        widths: Dict[int, float] = {
+        widths: dict[int, float] = {
             1: 18.0,
             2: 16.0,
             3: 12.0,

redmine_reporter/mailer.py

@@ -1,24 +1,18 @@
 """Отправка сгенерированного отчёта по email через SMTP."""
 
-import email.charset as _charset
 import os
 import smtplib
 from email.mime.application import MIMEApplication
 from email.mime.multipart import MIMEMultipart
 from email.mime.text import MIMEText
-from typing import Dict, List
 
 from .client import RedmineAPIError
 from .config import EmailConfig
 from .types import ReportRow
 
-# Use 8bit transfer encoding for UTF-8 so non-ASCII text (e.g. Russian)
-# appears literally in MIME output instead of base64.
-_charset.add_charset("utf-8", _charset.SHORTEST, None, "utf-8")
-
 SMTP_TIMEOUT = 30
 
-MIME_TYPES: Dict[str, str] = {
+MIME_TYPES: dict[str, str] = {
     ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
     ".odt": "application/vnd.oasis.opendocument.text",
     ".csv": "text/csv",
@@ -34,7 +28,21 @@ def _resolve_mime_type(file_path: str) -> str:
     return MIME_TYPES.get(ext, "application/octet-stream")
 
 
-def _build_html_body(rows: List[ReportRow]) -> str:
+def _utf8_text_part(text: str, subtype: str = "plain") -> MIMEText:
+    """Создаёт текстовую MIME-часть с 8bit UTF-8 телом.
+
+    Кодировка применяется точечно к части письма, без глобальной мутации
+    реестра email.charset: payload хранится как UTF-8 (surrogateescape),
+    а Content-Transfer-Encoding выставляется в 8bit, чтобы не-ASCII текст
+    (например, русский) передавался литерально, а не в base64.
+    """
+    part = MIMEText("", subtype, "utf-8")
+    part.set_payload(text.encode("utf-8").decode("ascii", "surrogateescape"))
+    part.replace_header("Content-Transfer-Encoding", "8bit")
+    return part
+
+
+def _build_html_body(rows: list[ReportRow]) -> str:
     """Генерирует HTML-версию тела письма через HTMLFormatter."""
     from .formatters.html import HTMLFormatter
 
@@ -47,7 +55,7 @@ def build_message(
     file_path: str,
     author: str,
     period: str,
-    rows: List[ReportRow],
+    rows: list[ReportRow],
 ) -> MIMEMultipart:
     """Формирует MIME-письмо с подстановками, телами и вложением."""
     subject = email_config.subject.replace("{author}", author).replace(
@@ -66,11 +74,11 @@ def build_message(
 
     # Тела письма: plain-text всегда, HTML по флагу
     body_container = MIMEMultipart("alternative")
-    body_container.attach(MIMEText(body, "plain", "utf-8"))
+    body_container.attach(_utf8_text_part(body))
 
     if email_config.html:
         html_body = _build_html_body(rows)
-        body_container.attach(MIMEText(html_body, "html", "utf-8"))
+        body_container.attach(_utf8_text_part(html_body, "html"))
 
     msg.attach(body_container)
 
@@ -99,7 +107,7 @@ def send_report(
     file_path: str,
     author: str,
     period: str,
-    rows: List[ReportRow],
+    rows: list[ReportRow],
 ) -> None:
     """Отправляет сгенерированный отчёт по email через SMTP.
 

redmine_reporter/report_builder.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, Optional, Tuple, cast
+from typing import cast
 
 from redminelib.resources import Issue
 
@@ -22,7 +22,7 @@ STATUS_TRANSLATION = {
 }
 
 
-def _format_activities(activities: Dict[str, float]) -> str:
+def _format_activities(activities: dict[str, float]) -> str:
     """Форматирует разбивку по активностям в многострочный текст."""
     if not activities:
         return ""
@@ -32,16 +32,22 @@ def _format_activities(activities: Dict[str, float]) -> str:
 
 
 def build_grouped_report(
-    issue_hours: List[Tuple[Issue, float, Optional[Dict[str, float]]]],
+    issue_hours: list[tuple[Issue, float, dict[str, float] | None]],
     fill_time: bool = True,
     by_activity: bool = False,
-) -> List[ReportRow]:
+    status_translation: dict[str, str] | None = None,
+) -> list[ReportRow]:
     """
     Преобразует список задач с затраченным временем в плоский список строк отчёта,
     с учётом группировки по проекту и версии (пустые ячейки для повторяющихся значений).
 
     Предусловие: issue_hours должен быть отсортирован по (project, version).
     Функция выполняет сортировку самостоятельно для защиты от несортированного ввода.
+
+    status_translation: перевод статусов; None — встроенный STATUS_TRANSLATION.
+    Переданный словарь ЗАМЕНЯЕТ встроенный полностью (без merge): статус,
+    отсутствующий в нём, выводится как есть (passthrough); пустой dict —
+    все статусы выводятся как есть.
     """
 
     # Защитная сортировка -- гарантирует корректную группировку независимо от порядка на входе
@@ -49,16 +55,20 @@ def build_grouped_report(
         issue_hours, key=lambda x: (str(x[0].project), get_version(x[0]), x[0].id)
     )
 
-    rows: List[ReportRow] = []
+    translation = (
+        status_translation if status_translation is not None else STATUS_TRANSLATION
+    )
+
+    rows: list[ReportRow] = []
     prev_project: str = ""
     prev_version: str = ""
 
     for issue, hours, *rest in issue_hours:
-        activities: Optional[Dict[str, float]] = rest[0] if rest else None
+        activities: dict[str, float] | None = 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)
+        status_ru = translation.get(status_en, status_en)
 
         if fill_time:
             if by_activity and activities:
@@ -98,14 +108,14 @@ def build_grouped_report(
 
 
 def calculate_summary(
-    rows: List[ReportRow],
+    rows: list[ReportRow],
     by_activity: bool = False,
-) -> Dict[str, float]:
+) -> dict[str, float]:
     """Возвращает сводку: общее время, время по проектам, версиям и активностям."""
     total = 0.0
-    by_project: Dict[str, float] = {}
-    by_project_version: Dict[str, float] = {}
-    by_activity_name: Dict[str, float] = {}
+    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)
@@ -120,7 +130,7 @@ def calculate_summary(
                 for name, act_hours in activities.items():
                     by_activity_name[name] = by_activity_name.get(name, 0.0) + act_hours
 
-    result: Dict[str, float] = {
+    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()},
@@ -134,8 +144,8 @@ def calculate_summary(
 
 
 def group_rows_by_project_and_version(
-    rows: List[ReportRow],
-) -> Dict[str, Dict[str, List[ReportRow]]]:
+    rows: list[ReportRow],
+) -> dict[str, dict[str, list[ReportRow]]]:
     """
     Группирует плоский список строк отчёта в иерархию project → version → [rows].
 
@@ -143,7 +153,7 @@ def group_rows_by_project_and_version(
     Возвращает обычный dict, сохраняющий порядок вставки (Python 3.7+).
     Используется форматтерами HTML и ODT для объединения ячеек.
     """
-    projects: Dict[str, Dict[str, List[ReportRow]]] = {}
+    projects: dict[str, dict[str, list[ReportRow]]] = {}
     for r in rows:
         project = r["project"]
         version = r["version"]

redmine_reporter/task_list.py

@@ -0,0 +1,149 @@
+from datetime import date
+
+from redminelib.resources import Issue
+
+from .types import TaskRow, TaskSummary
+from .utils import get_version
+
+# В этом Redmine ровно пять приоритетов P1..P5; меньший номер -- срочнее.
+PRIORITY_RANK: dict[str, int] = {"P1": 1, "P2": 2, "P3": 3, "P4": 4, "P5": 5}
+
+# Ранг для неизвестного имени приоритета: такие задачи уходят в самый конец.
+LOWEST_PRIORITY_RANK = len(PRIORITY_RANK) + 1
+
+
+def priority_rank(name: str) -> int:
+    """Возвращает ранг приоритета; неизвестное имя получает низший ранг."""
+    return PRIORITY_RANK.get(name, LOWEST_PRIORITY_RANK)
+
+
+def _issue_version_name(issue: Issue) -> str:
+    """Имя версии задачи или пустая строка, если версия не назначена."""
+    return get_version(issue, default="")
+
+
+# "Wishlist" -- постоянная бакет-версия без срока (личный бакет Wendy, факт
+# из трекера): задачи в ней -- отложенные идеи, создающие мусорный фон в
+# персональной выборке, поэтому режим --my-tasks исключает их целиком --
+# из таблицы и из саммари. Сравнение имени точное, без нормализации регистра.
+EXCLUDED_VERSION_NAMES: frozenset[str] = frozenset({"Wishlist"})
+
+
+def filter_excluded_versions(
+    items: list[tuple[Issue, date | None]],
+) -> list[tuple[Issue, date | None]]:
+    """Убирает задачи версий-исключений из выборки --my-tasks.
+
+    Доступ к fixed_version.name getattr-безопасный: задача без версии или
+    с версией без имени остаётся в выборке. Даты в парах сохраняются как есть.
+    """
+    kept: list[tuple[Issue, date | None]] = []
+    for item in items:
+        version = getattr(item[0], "fixed_version", None)
+        name = getattr(version, "name", None) if version is not None else None
+        if name and str(name) in EXCLUDED_VERSION_NAMES:
+            continue
+        kept.append(item)
+    return kept
+
+
+def _sort_key(item: tuple[Issue, date | None]) -> tuple[int, bool, date, int]:
+    """Ключ сортировки: приоритет, затем срок по возрастанию, затем id.
+
+    Задачи без срока уходят в конец своей приоритетной группы: флаг
+    (due is None) сортирует False раньше True, а date.max служит нейтральным
+    значением, чтобы сравнение дат осталось корректным.
+    """
+    issue, due = item
+    rank = priority_rank(str(issue.priority.name))
+    return (rank, due is None, due if due is not None else date.max, issue.id)
+
+
+def build_task_rows(
+    items: list[tuple[Issue, date | None]],
+    status_translation: dict[str, str],
+    today: date | None = None,
+) -> list[TaskRow]:
+    """Строит отсортированный список строк режима --my-tasks.
+
+    items -- пары (задача, срок версии или None). today параметризован
+    для тестируемости; по умолчанию берётся текущая дата.
+    """
+    if today is None:
+        today = date.today()
+
+    rows: list[TaskRow] = []
+    for issue, due in sorted(items, key=_sort_key):
+        status_name = str(issue.status)
+        rows.append(
+            {
+                "issue_id": issue.id,
+                "subject": str(issue.subject),
+                "status_ru": status_translation.get(status_name, status_name),
+                "priority": str(issue.priority.name),
+                "version_name": _issue_version_name(issue),
+                "due_text": due.isoformat() if due is not None else "",
+                "overdue": due is not None and due < today,
+            }
+        )
+    return rows
+
+
+def calculate_task_summary(
+    items: list[tuple[Issue, date | None]],
+    today: date | None = None,
+) -> TaskSummary:
+    """Считает саммари по списку пар (задача, срок версии или None)."""
+    if today is None:
+        today = date.today()
+
+    overdue = 0
+    no_version = 0
+    no_due = 0
+    spent_hours = 0.0
+    estimated_hours = 0.0
+    estimated_count = 0
+
+    for issue, due in items:
+        if due is not None and due < today:
+            overdue += 1
+
+        version = getattr(issue, "fixed_version", None)
+        if version is None:
+            no_version += 1
+        elif due is None:
+            no_due += 1
+
+        raw_spent = getattr(issue, "spent_hours", None)
+        if raw_spent is not None:
+            spent_hours += float(raw_spent)
+
+        raw_estimated = getattr(issue, "estimated_hours", None)
+        if raw_estimated is not None:
+            estimated_hours += float(raw_estimated)
+            estimated_count += 1
+
+    return {
+        "total": len(items),
+        "overdue": overdue,
+        "no_version": no_version,
+        "no_due": no_due,
+        "spent_hours": spent_hours,
+        "estimated_hours": estimated_hours,
+        "estimated_count": estimated_count,
+    }
+
+
+def format_summary_line(s: TaskSummary) -> str:
+    """Форматирует однострочное саммари; блок оценки выводится при наличии данных."""
+    line = (
+        f"Открытых: {s['total']} | просроченных: {s['overdue']}"
+        f" | без версии: {s['no_version']} | без срока: {s['no_due']}"
+        f" | потрачено: {s['spent_hours']:g}h"
+    )
+    if s["estimated_count"] > 0:
+        line += (
+            f" | оценка: {s['estimated_hours']:g}h"
+            f" (по {s['estimated_count']} из {s['total']})"
+        )
+    return line

redmine_reporter/types.py

@@ -1,4 +1,4 @@
-from typing import Dict, Optional, TypedDict
+from typing import TypedDict
 
 
 class ReportRowBase(TypedDict):
@@ -18,4 +18,28 @@ class ReportRowBase(TypedDict):
 class ReportRow(ReportRowBase, total=False):
     """Строка итогового отчёта с опциональной разбивкой по активностям."""
 
-    activities: Optional[Dict[str, float]]
+    activities: dict[str, float] | None
+
+
+class TaskRow(TypedDict):
+    """Строка списка открытых задач пользователя (режим --my-tasks)."""
+
+    issue_id: int
+    subject: str
+    status_ru: str
+    priority: str
+    version_name: str
+    due_text: str
+    overdue: bool
+
+
+class TaskSummary(TypedDict):
+    """Саммари списка открытых задач пользователя."""
+
+    total: int
+    overdue: int
+    no_version: int
+    no_due: int
+    spent_hours: float
+    estimated_hours: float
+    estimated_count: int

redmine_reporter/utils.py

@@ -28,11 +28,11 @@ def get_month_name_from_range(from_date: str, to_date: str) -> str:
     return months[end.month]
 
 
-def get_version(issue) -> str:
-    """Возвращает версию задачи или '<N/A>', если не задана."""
+def get_version(issue, default: str = "<N/A>") -> str:
+    """Возвращает версию задачи или default, если не задана."""
     version = getattr(issue, "fixed_version", None)
     if version is None:
-        return "<N/A>"
+        return default
     name = getattr(version, "name", None)
     return str(name) if name else str(version)
 

redmine_reporter/yaml_config.py

@@ -153,19 +153,11 @@ def resolve_output_path(
     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.
+def save_period_to_config(config_path: str, from_str: str) -> None:
+    """Save committed period start 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.
+    Writes period.from only: all other sections and keys stay untouched.
+    Creates the config file (and its parent directory) if missing.
     """
     import yaml
 
@@ -176,11 +168,7 @@ def save_period_to_config(
             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
+    period["from"] = from_str
 
     ensure_config_dir(path.parent)
     with open(path, "w", encoding="utf-8") as fh:

tests/test_client.py

@@ -1,9 +1,10 @@
 import os
+from datetime import date
 from unittest import mock
 
 import pytest
 
-from redmine_reporter.client import fetch_issues_with_spent_time
+from redmine_reporter.client import fetch_issues_with_spent_time, fetch_open_issues
 from redmine_reporter.config import DEFAULT_REDMINE_VERIFY
 
 PASSWORD_ENV = {
@@ -19,6 +20,18 @@ def _configure_current_user(mock_redmine, user_id=1):
     mock_redmine.user.get.return_value = mock_user
 
 
+@pytest.fixture(autouse=True)
+def mock_truststore():
+    """Мок truststore для всех тестов клиента.
+
+    При verify=True _create_redmine() вызывает truststore.inject_into_ssl(),
+    который глобально подменяет ssl.SSLContext без восстановления (#62).
+    Не даём реальной инъекции выполниться в pytest-процессе.
+    """
+    with mock.patch("redmine_reporter.client.truststore") as m:
+        yield m
+
+
 @mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
 @mock.patch("redmine_reporter.client.Redmine")
 def test_fetch_aggregates_hours_per_issue(mock_redmine_class):
@@ -45,7 +58,7 @@ def test_fetch_aggregates_hours_per_issue(mock_redmine_class):
 
     assert result is not None
     assert len(result) == 1
-    issue, total_hours, _activities = result[0]
+    _issue, total_hours, _activities = result[0]
     assert total_hours == 3.5
 
 
@@ -172,6 +185,70 @@ def test_fetch_uses_custom_verify_path(mock_redmine_class):
     assert kwargs["requests"]["verify"] == "/tmp/redmine-ca.pem"
 
 
+@mock.patch.dict(os.environ, {**PASSWORD_ENV, "REDMINE_VERIFY": "true"}, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_verify_true_injects_system_trust_store(mock_redmine_class, mock_truststore):
+    """verify=True → truststore.inject_into_ssl() вызван, verify=True в Redmine (#62)."""
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine)
+    mock_redmine.time_entry.filter.return_value = []
+
+    fetch_issues_with_spent_time("2026-01-01", "2026-01-31")
+
+    mock_truststore.inject_into_ssl.assert_called_once_with()
+    _, kwargs = mock_redmine_class.call_args
+    assert kwargs["requests"]["verify"] is True
+
+
+@mock.patch.dict(os.environ, {**PASSWORD_ENV, "REDMINE_VERIFY": "false"}, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_verify_false_skips_truststore_injection(mock_redmine_class, mock_truststore):
+    """verify=False → truststore.inject_into_ssl() не вызывается."""
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine)
+    mock_redmine.time_entry.filter.return_value = []
+
+    fetch_issues_with_spent_time("2026-01-01", "2026-01-31")
+
+    mock_truststore.inject_into_ssl.assert_not_called()
+    _, kwargs = mock_redmine_class.call_args
+    assert kwargs["requests"]["verify"] is False
+
+
+@mock.patch.dict(
+    os.environ, {**PASSWORD_ENV, "REDMINE_VERIFY": "/tmp/redmine-ca.pem"}, clear=True
+)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_verify_custom_path_skips_truststore_injection(
+    mock_redmine_class, mock_truststore
+):
+    """verify=<путь к CA-bundle> → truststore.inject_into_ssl() не вызывается."""
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine)
+    mock_redmine.time_entry.filter.return_value = []
+
+    fetch_issues_with_spent_time("2026-01-01", "2026-01-31")
+
+    mock_truststore.inject_into_ssl.assert_not_called()
+    _, kwargs = mock_redmine_class.call_args
+    assert kwargs["requests"]["verify"] == "/tmp/redmine-ca.pem"
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_verify_default_injects_system_trust_store(mock_redmine_class, mock_truststore):
+    """Без REDMINE_VERIFY verify по умолчанию True → inject вызван (#62)."""
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine)
+    mock_redmine.time_entry.filter.return_value = []
+
+    fetch_issues_with_spent_time("2026-01-01", "2026-01-31")
+
+    mock_truststore.inject_into_ssl.assert_called_once_with()
+    _, kwargs = mock_redmine_class.call_args
+    assert kwargs["requests"]["verify"] is True
+
+
 @mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
 @mock.patch("redmine_reporter.client.Redmine")
 def test_fetch_raises_redmine_api_error_on_auth(mock_redmine_class):
@@ -275,6 +352,7 @@ def test_fetch_resolves_user_login_to_id(mock_redmine_class):
 
     mock_user = mock.MagicMock()
     mock_user.id = 7
+    mock_user.login = "ivanov"
     mock_redmine.user.filter.return_value = [mock_user]
     mock_redmine.time_entry.filter.return_value = []
 
@@ -287,6 +365,91 @@ def test_fetch_resolves_user_login_to_id(mock_redmine_class):
     assert kwargs["user_id"] == 7
 
 
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_fetch_rejects_inexact_login_match(mock_redmine_class):
+    """Фильтр Redmine по логину неточный (#60): без точного совпадения — ошибка."""
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine)
+
+    near_match = mock.MagicMock()
+    near_match.id = 8
+    near_match.login = "ivanov2"
+    mock_redmine.user.filter.side_effect = [
+        [near_match],  # неточное совпадение по логину
+        [],  # по имени никого не найдено
+    ]
+
+    from redmine_reporter.client import RedmineAPIError
+
+    with pytest.raises(RedmineAPIError, match="not found"):
+        fetch_issues_with_spent_time("2026-01-01", "2026-01-31", user_id="ivanov")
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_fetch_resolves_exact_login_among_near_matches(mock_redmine_class):
+    """Среди неточных результатов фильтра выбирается точное совпадение логина (#60)."""
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine)
+
+    near = mock.MagicMock()
+    near.id = 8
+    near.login = "ivanov2"
+    exact = mock.MagicMock()
+    exact.id = 7
+    exact.login = "ivanov"
+    mock_redmine.user.filter.return_value = [near, exact]
+    mock_redmine.time_entry.filter.return_value = []
+
+    fetch_issues_with_spent_time("2026-01-01", "2026-01-31", user_id="ivanov")
+
+    _, kwargs = mock_redmine.time_entry.filter.call_args
+    assert kwargs["user_id"] == 7
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_fetch_rejects_multiple_exact_login_matches(mock_redmine_class):
+    """Несколько пользователей с точным логином — ошибка неоднозначности (#60)."""
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine)
+
+    user1 = mock.MagicMock()
+    user1.id = 7
+    user1.login = "ivanov"
+    user2 = mock.MagicMock()
+    user2.id = 9
+    user2.login = "ivanov"
+    mock_redmine.user.filter.return_value = [user1, user2]
+
+    from redmine_reporter.client import RedmineAPIError
+
+    with pytest.raises(RedmineAPIError, match="Multiple users match"):
+        fetch_issues_with_spent_time("2026-01-01", "2026-01-31", user_id="ivanov")
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_fetch_login_exact_match_is_case_sensitive(mock_redmine_class):
+    """Точное совпадение логина регистрозависимое (#60)."""
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine)
+
+    other_case = mock.MagicMock()
+    other_case.id = 8
+    other_case.login = "Ivanov"
+    mock_redmine.user.filter.side_effect = [
+        [other_case],  # логин отличается регистром
+        [],  # по имени никого не найдено
+    ]
+
+    from redmine_reporter.client import RedmineAPIError
+
+    with pytest.raises(RedmineAPIError, match="not found"):
+        fetch_issues_with_spent_time("2026-01-01", "2026-01-31", user_id="ivanov")
+
+
 @mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
 @mock.patch("redmine_reporter.client.Redmine")
 def test_fetch_resolves_user_name_to_id(mock_redmine_class):
@@ -443,33 +606,36 @@ def test_fetch_chunks_large_issue_count(mock_redmine_class):
     assert len(result) == 250
 
 
-# -- #47: Дедупликация time entries по datetime --
+# -- Пагинация time entries (>100 записей) --
 
 
 @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
-
+def test_fetch_aggregates_hours_across_all_pages(mock_redmine_class):
+    """Time entries приходят страницами по 100 — часы агрегируются по всем страницам."""
     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)
+    def make_entry(issue_id, hours):
+        e = mock.MagicMock()
+        e.issue.id = issue_id
+        e.hours = hours
+        return e
 
-    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)
+    # Эмулируем ленивую пагинацию redminelib ResourceSet: записи отдаются
+    # генератором порциями ("страницами" по 100), как при догрузке с сервера.
+    # Если клиент прочитает только первую страницу, агрегация будет неверной.
+    pages = [
+        [make_entry(1, 0.5) for _ in range(100)],
+        [make_entry(2, 1.0) for _ in range(100)],
+        [make_entry(1, 0.5) for _ in range(50)],
+    ]
 
-    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)
+    def paged_entries():
+        for page in pages:
+            yield from page
 
-    mock_redmine.time_entry.filter.return_value = [e1, e2]
+    mock_redmine.time_entry.filter.return_value = paged_entries()
 
     mock_issue1 = mock.MagicMock()
     mock_issue1.id = 1
@@ -479,215 +645,361 @@ def test_dedup_filters_entries_created_before_cutoff(mock_redmine_class):
     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
-    )
+    result = fetch_issues_with_spent_time("2026-01-01", "2026-03-31")
 
     assert result is not None
-    assert len(result) == 1
-    assert result[0][0].id == 2
+    hours_by_id = {issue.id: hours for issue, hours, _ in result}
+    # issue 1: 100×0.5 (стр. 1) + 50×0.5 (стр. 3) = 75.0
+    assert hours_by_id[1] == 75.0
+    # issue 2: 100×1.0 (стр. 2) = 100.0
+    assert hours_by_id[2] == 100.0
+
+
+# -- #61: предупреждения о молчаливой потере данных --
 
 
 @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
+def test_fetch_warns_about_missing_issues(mock_redmine_class, capsys):
+    """Задачи, не вернувшиеся из issue.filter, попадают в warning в stderr (#61).
 
+    Отчёт при этом строится по доступным данным — это предупреждение, не ошибка.
+    """
     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)
+    def make_entry(issue_id, hours):
+        e = mock.MagicMock()
+        e.issue.id = issue_id
+        e.hours = hours
+        return e
 
-    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 = [
+        make_entry(1, 1.0),
+        make_entry(2, 2.5),
+        make_entry(3, 0.75),
+    ]
 
-    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"
+    # Задачи 2 и 3 не вернулись (нет прав / удалены)
+    mock_redmine.issue.filter.return_value = [mock_issue1]
+
+    result = fetch_issues_with_spent_time("2026-01-01", "2026-01-31")
+
+    assert result is not None
+    assert [r[0].id for r in result] == [1]
+
+    captured = capsys.readouterr()
+    assert "2" in captured.err
+    assert "3" in captured.err
+    assert "3.25" in captured.err  # сумма потерянных часов 2.5 + 0.75
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_fetch_no_warning_when_all_issues_returned(mock_redmine_class, capsys):
+    """Если все задачи вернулись, stderr остаётся чистым (#61)."""
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine, user_id=123)
+
+    e = mock.MagicMock()
+    e.issue.id = 1
+    e.hours = 1.0
+    mock_redmine.time_entry.filter.return_value = [e]
+
+    mock_issue1 = mock.MagicMock()
+    mock_issue1.id = 1
+    mock_redmine.issue.filter.return_value = [mock_issue1]
+
+    result = fetch_issues_with_spent_time("2026-01-01", "2026-01-31")
+
+    assert result is not None
+    captured = capsys.readouterr()
+    assert captured.err == ""
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_fetch_warns_when_activities_lookup_fails(mock_redmine_class, capsys):
+    """Сбой справочника активностей — warning в stderr, отчёт строится (#61)."""
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine, user_id=123)
+    mock_redmine.enumeration.filter.side_effect = Exception("enumeration boom")
+
+    e = mock.MagicMock()
+    e.issue.id = 1
+    e.hours = 1.0
+    e.activity.id = 9
+    e.activity.name = "Dev"
+    mock_redmine.time_entry.filter.return_value = [e]
+
+    mock_issue1 = mock.MagicMock()
+    mock_issue1.id = 1
+    mock_redmine.issue.filter.return_value = [mock_issue1]
+
+    result = fetch_issues_with_spent_time("2026-01-01", "2026-01-31", by_activity=True)
+
+    assert result is not None
+    assert result[0][2] == {"Dev": 1.0}  # fallback на имя из самого entry
+
+    captured = capsys.readouterr()
+    assert "activit" in captured.err.lower()
+
+
+def test_load_time_entry_activities_returns_empty_on_failure(capsys):
+    """_load_time_entry_activities возвращает {} и пишет warning при сбое (#61)."""
+    from redmine_reporter.client import _load_time_entry_activities
+
+    redmine = mock.MagicMock()
+    redmine.enumeration.filter.side_effect = Exception("enumeration boom")
+
+    assert _load_time_entry_activities(redmine) == {}
+
+    captured = capsys.readouterr()
+    assert "activit" in captured.err.lower()
+
+
+# -- Границы периода передаются в API как есть --
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_fetch_passes_date_boundaries_to_api_unchanged(mock_redmine_class):
+    """Флоринг границ выполняет cli-парсер, клиент отдаёт даты в filter как есть."""
+    mock_redmine = mock_redmine_class.return_value
+    mock_redmine.time_entry.filter.return_value = []
+
+    fetch_issues_with_spent_time("2026-09-30", "2026-10-31", user_id=458)
+
+    mock_redmine.time_entry.filter.assert_called_once_with(
+        user_id=458, from_date="2026-09-30", to_date="2026-10-31"
+    )
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_fetch_works_without_dedup_argument(mock_redmine_class):
+    """dedup-слой удалён: без dedup-аргумента все записи периода агрегируются."""
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine, user_id=123)
+
+    entry = mock.MagicMock()
+    entry.issue.id = 1
+    entry.hours = 2.0
+    entry.created_on = None
+    entry.updated_on = None
+    mock_redmine.time_entry.filter.return_value = [entry]
+
+    mock_issue = mock.MagicMock()
+    mock_issue.id = 1
+    mock_issue.project = "P"
+    mock_issue.subject = "T"
+    mock_issue.status = "New"
+    mock_redmine.issue.filter.return_value = [mock_issue]
+
+    result = fetch_issues_with_spent_time("2026-09-30", "2026-09-30", user_id=123)
+
+    assert result is not None
+    assert [r[0].id for r in result] == [1]
+    assert result[0][1] == 2.0
+
+
+# -- #71: fetch_open_issues --
+
+
+def _make_open_issue(issue_id, version_id=None):
+    """Создаёт mock открытой задачи; без version_id эмулирует отсутствие fixed_version.
+
+    Спека без fixed_version нужна, чтобы getattr(issue, "fixed_version", None)
+    вернул None, а не auto-атрибут MagicMock.
+    """
+    if version_id is None:
+        issue = mock.MagicMock(spec=["id", "subject", "project"])
+        issue.id = issue_id
+        return issue
+    issue = mock.MagicMock()
+    issue.id = issue_id
+    issue.fixed_version.id = version_id
+    return issue
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_open_issues_filters_by_user_and_open_status(mock_redmine_class):
+    """issue.filter вызван ровно с assigned_to_id и status_id="open" (#71)."""
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine, user_id=123)
     mock_redmine.issue.filter.return_value = []
 
-    result = fetch_issues_with_spent_time(
-        "2026-07-01", "2026-07-01", dedup_before=dedup_cutoff
-    )
+    fetch_open_issues()
 
-    assert result is None
+    mock_redmine.issue.filter.assert_called_once_with(
+        assigned_to_id=123, status_id="open"
+    )
 
 
 @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
-
+def test_open_issues_default_user_is_current(mock_redmine_class):
+    """Без user_id резолвится текущий пользователь через user.get("current") (#71)."""
     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]
+    _configure_current_user(mock_redmine, user_id=77)
     mock_redmine.issue.filter.return_value = []
 
-    result = fetch_issues_with_spent_time(
-        "2026-07-01", "2026-07-01", dedup_before=dedup_cutoff
-    )
+    fetch_open_issues()
 
-    assert result is None
+    mock_redmine.user.get.assert_called_once_with("current")
+    _, kwargs = mock_redmine.issue.filter.call_args
+    assert kwargs["assigned_to_id"] == 77
 
 
 @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 фильтрация не применяется."""
+def test_open_issues_numeric_user_id_skips_user_lookup(mock_redmine_class):
+    """Числовой user_id: user.get не вызывается, фильтр по переданному ID (#71)."""
     mock_redmine = mock_redmine_class.return_value
-    _configure_current_user(mock_redmine, user_id=123)
+    mock_redmine.issue.filter.return_value = []
 
-    e1 = mock.MagicMock()
-    e1.issue.id = 1
-    e1.hours = 2.0
-    e1.created_on = None
-    e1.updated_on = None
+    fetch_open_issues(user_id=42)
 
-    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_redmine.user.get.assert_not_called()
+    mock_redmine.issue.filter.assert_called_once_with(
+        assigned_to_id=42, status_id="open"
+    )
 
 
 @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
+def test_open_issues_resolves_login_to_id(mock_redmine_class):
+    """Строковый логин разрешается в числовой ID как в fetch_issues_with_spent_time (#71)."""
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine)
+
+    mock_user = mock.MagicMock()
+    mock_user.id = 7
+    mock_user.login = "ivanov"
+    mock_redmine.user.filter.return_value = [mock_user]
+    mock_redmine.issue.filter.return_value = []
+
+    fetch_open_issues(user_id="ivanov")
+
+    login_filter_call = mock_redmine.user.filter.call_args_list[0]
+    assert login_filter_call.kwargs == {"login": "ivanov"}
+    mock_redmine.issue.filter.assert_called_once_with(
+        assigned_to_id=7, status_id="open"
+    )
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_open_issues_fetches_each_unique_version_once(mock_redmine_class):
+    """Две задачи с одной версией -> один version.get на версию (#71)."""
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine, user_id=123)
+    mock_redmine.issue.filter.return_value = [
+        _make_open_issue(1, version_id=5),
+        _make_open_issue(2, version_id=5),
+        _make_open_issue(3, version_id=6),
+    ]
+
+    result = fetch_open_issues()
+
+    assert mock_redmine.version.get.call_count == 2
+    version_ids = [call.args[0] for call in mock_redmine.version.get.call_args_list]
+    assert version_ids == [5, 6]
+    assert len(result) == 3
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_open_issues_attaches_version_due_date(mock_redmine_class):
+    """due_date из version.get попадает в кортеж задачи (#71)."""
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine, user_id=123)
+    mock_redmine.issue.filter.return_value = [_make_open_issue(1, version_id=5)]
+    mock_redmine.version.get.return_value = mock.MagicMock(due_date=date(2026, 11, 1))
+
+    result = fetch_open_issues()
+
+    assert result is not None
+    issue, due = result[0]
+    assert issue.id == 1
+    assert due == date(2026, 11, 1)
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_open_issues_issue_without_version_has_empty_due(mock_redmine_class):
+    """Задача без fixed_version: version.get для неё не вызывается, due None (#71)."""
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine, user_id=123)
+    mock_redmine.issue.filter.return_value = [
+        _make_open_issue(1, version_id=5),
+        _make_open_issue(2),
+    ]
+    mock_redmine.version.get.return_value = mock.MagicMock(due_date=date(2026, 11, 1))
+
+    result = fetch_open_issues()
+
+    mock_redmine.version.get.assert_called_once_with(5)
+    assert result is not None
+    assert result[1][0].id == 2
+    assert result[1][1] is None
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_open_issues_version_failure_warns_and_continues(mock_redmine_class, capsys):
+    """Сбой version.get: warning в stderr, due None, общий результат не валится (#71)."""
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine, user_id=123)
+    mock_redmine.issue.filter.return_value = [_make_open_issue(1, version_id=5)]
+    mock_redmine.version.get.side_effect = Exception("version boom")
+
+    result = fetch_open_issues()
+
+    assert result is not None
+    assert result[0][1] is None
+
+    captured = capsys.readouterr()
+    assert "Could not load version 5" in captured.err
+    assert "version boom" in captured.err
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_open_issues_result_length_matches_issues(mock_redmine_class):
+    """Результат по длине и порядку соответствует списку задач из API (#71)."""
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine, user_id=123)
+    mock_redmine.issue.filter.return_value = [
+        _make_open_issue(1, version_id=5),
+        _make_open_issue(2),
+        _make_open_issue(3, version_id=6),
+    ]
+
+    result = fetch_open_issues()
+
+    assert result is not None
+    assert len(result) == 3
+    assert [issue.id for issue, _ in result] == [1, 2, 3]
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_open_issues_wraps_api_errors(mock_redmine_class):
+    """Сбой issue.filter оборачивается в RedmineAPIError с понятным сообщением (#71)."""
+    from redminelib.exceptions import AuthError
 
     mock_redmine = mock_redmine_class.return_value
     _configure_current_user(mock_redmine, user_id=123)
+    mock_redmine.issue.filter.side_effect = AuthError()
 
-    dedup_cutoff = datetime(2026, 7, 1, 12, 0, 0, tzinfo=timezone.utc)
+    from redmine_reporter.client import RedmineAPIError
 
-    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}
+    with pytest.raises(RedmineAPIError, match="Authentication failed"):
+        fetch_open_issues()

tests/test_config.py

@@ -1,16 +1,25 @@
+import contextlib
 import os
 import tempfile
 from pathlib import Path
+from typing import ClassVar
 from unittest import mock
 
 import pytest
 
-from redmine_reporter.config import (
-    DEFAULT_REDMINE_VERIFY,
-    AppConfig,
-    Config,
-    EmailConfig,
-)
+from redmine_reporter.config import AppConfig, Config, EmailConfig
+
+
+@contextlib.contextmanager
+def mock_today(fake_today):
+    """Подменяет date.today() в config, сохраняя реальные date() и fromisoformat()."""
+    from datetime import date as real_date
+
+    with mock.patch("redmine_reporter.config.date") as mock_date:
+        mock_date.today.return_value = fake_today
+        mock_date.side_effect = lambda *a, **kw: real_date(*a, **kw)
+        mock_date.fromisoformat.side_effect = real_date.fromisoformat
+        yield
 
 
 @mock.patch.dict(
@@ -67,25 +76,9 @@ def test_get_author_fallback():
     assert Config.get_author("") == ""
 
 
-@mock.patch.dict(
-    os.environ,
-    {
-        "DEFAULT_FROM_DATE": "2026-01-01",
-        "DEFAULT_TO_DATE": "2026-01-31",
-    },
-    clear=True,
-)
+@mock.patch.dict(os.environ, {"FROM_DATE": "2026-01-01"}, clear=True)
 def test_get_default_date_range_from_env():
-    assert Config.get_default_date_range() == "2026-01-01--2026-01-31"
-
-
-@mock.patch.dict(
-    os.environ,
-    {"DEFAULT_FROM_DATE": "2026-01-01"},
-    clear=True,
-)
-def test_get_default_date_range_from_env_without_to():
-    """Если DEFAULT_TO_DATE не задан, конец периода — сегодня."""
+    """FROM_DATE задаёт начало периода, конец всегда -- сегодня."""
     from datetime import date
 
     today = date.today().isoformat()
@@ -104,9 +97,129 @@ def test_get_default_date_range_fallback():
     assert result == f"{start.isoformat()}--{today.isoformat()}"
 
 
+# -- #56: дефолтный период — текущий месяц (детерминированные тесты) --
+
+
+class TestDefaultPeriodIsCurrentMonth:
+    """Без --date, env и YAML период = с 1-го числа текущего месяца по сегодня."""
+
+    @mock.patch.dict(os.environ, {}, clear=True)
+    def test_mid_month(self):
+        from datetime import date
+
+        with mock.patch("redmine_reporter.config.date") as mock_date:
+            mock_date.today.return_value = date(2026, 3, 14)
+            mock_date.side_effect = lambda *a, **kw: date(*a, **kw)
+            Config._app = None
+            assert Config.get_default_date_range() == "2026-03-01--2026-03-14"
+
+    @mock.patch.dict(os.environ, {}, clear=True)
+    def test_first_day_of_month(self):
+        from datetime import date
+
+        with mock.patch("redmine_reporter.config.date") as mock_date:
+            mock_date.today.return_value = date(2026, 5, 1)
+            mock_date.side_effect = lambda *a, **kw: date(*a, **kw)
+            Config._app = None
+            assert Config.get_default_date_range() == "2026-05-01--2026-05-01"
+
+    @mock.patch.dict(os.environ, {}, clear=True)
+    def test_yaml_period_from_runs_to_today(self):
+        """period.from задан -- конец периода всегда сегодня."""
+        from datetime import date
+
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text("period:\n  from: '2026-04-01'\n")
+            Config._app = AppConfig.from_yaml(yaml_path)
+
+        with mock_today(date(2026, 4, 20)):
+            assert Config.get_default_date_range() == "2026-04-01--2026-04-20"
+
+
+class TestDefaultDateRangePeriodFrom:
+    """Приоритет окна: env FROM_DATE → YAML period.from → текущий месяц."""
+
+    @mock.patch.dict(os.environ, {"FROM_DATE": "2026-02-01"}, clear=True)
+    def test_env_from_runs_to_today(self):
+        """FROM_DATE задаёт начало, конец всегда сегодня."""
+        from datetime import date
+
+        Config._app = None
+        with mock_today(date(2026, 2, 10)):
+            assert Config.get_default_date_range() == "2026-02-01--2026-02-10"
+
+    @mock.patch.dict(os.environ, {"FROM_DATE": "2026-07-01"}, clear=True)
+    def test_env_from_wins_over_yaml_period_from(self):
+        """env FROM_DATE имеет приоритет над YAML period.from."""
+        from datetime import date
+
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text("period:\n  from: '2026-03-01'\n")
+            Config._app = AppConfig.from_yaml(yaml_path)
+
+        with mock_today(date(2026, 7, 15)):
+            assert Config.get_default_date_range() == "2026-07-01--2026-07-15"
+
+    @mock.patch.dict(os.environ, {"FROM_DATE": "2026-12-31"}, clear=True)
+    def test_env_from_in_future_clamps_to_today(self):
+        """from позже сегодня -- окно 'сегодня--сегодня', без инверсии."""
+        from datetime import date
+
+        Config._app = None
+        with mock_today(date(2026, 9, 15)):
+            assert Config.get_default_date_range() == "2026-09-15--2026-09-15"
+
+    @mock.patch.dict(os.environ, {}, clear=True)
+    def test_yaml_period_from_in_future_clamps_to_today(self):
+        """YAML period.from позже сегодня -- окно 'сегодня--сегодня'."""
+        from datetime import date
+
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text("period:\n  from: '2026-12-31'\n")
+            Config._app = AppConfig.from_yaml(yaml_path)
+
+        with mock_today(date(2026, 9, 15)):
+            assert Config.get_default_date_range() == "2026-09-15--2026-09-15"
+
+    @mock.patch.dict(os.environ, {}, clear=True)
+    def test_malformed_yaml_period_from_warns_and_uses_current_month(self, caplog):
+        """period.from не дата -- warning в лог, окно = текущий месяц."""
+        import logging
+        from datetime import date
+
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text("period:\n  from: 'not-a-date'\n")
+            Config._app = AppConfig.from_yaml(yaml_path)
+
+        with caplog.at_level(logging.WARNING), mock_today(date(2026, 9, 15)):
+            rng = Config.get_default_date_range()
+
+        assert rng == "2026-09-01--2026-09-15"
+        assert "not-a-date" in caplog.text
+
+    @mock.patch.dict(os.environ, {"FROM_DATE": "garbage"}, clear=True)
+    def test_malformed_env_from_warns_and_uses_current_month(self, caplog):
+        """FROM_DATE не дата -- warning в лог, окно = текущий месяц."""
+        import logging
+        from datetime import date
+
+        Config._app = None
+        with caplog.at_level(logging.WARNING), mock_today(date(2026, 9, 15)):
+            rng = Config.get_default_date_range()
+
+        assert rng == "2026-09-01--2026-09-15"
+        assert "garbage" in caplog.text
+
+
 @mock.patch.dict(os.environ, {}, clear=True)
 def test_get_redmine_verify_default():
-    assert Config.get_redmine_verify() == DEFAULT_REDMINE_VERIFY
+    """Без явной настройки проверка TLS включена (стандартные CA requests)."""
+    Config._app = None
+    assert Config.get_redmine_verify() is True
 
 
 @pytest.mark.parametrize("value", ["0", "false", "False", "no", "off"])
@@ -126,17 +239,106 @@ def test_get_redmine_verify_custom_path():
     assert Config.get_redmine_verify() == "/tmp/redmine-ca.pem"
 
 
+# -- #54: REDMINE_URL обязан использовать HTTPS --
+
+
+class TestConfigRequiresHttpsUrl:
+    """Config.validate() отклоняет URL без TLS: API-ключ идёт в заголовках."""
+
+    @mock.patch.dict(
+        os.environ,
+        {"REDMINE_URL": "http://red.eltex.loc/", "REDMINE_API_KEY": "token"},
+        clear=True,
+    )
+    def test_http_url_rejected(self):
+        with pytest.raises(ValueError, match="HTTPS"):
+            Config.validate()
+
+    @mock.patch.dict(
+        os.environ,
+        {"REDMINE_URL": "red.eltex.loc", "REDMINE_API_KEY": "token"},
+        clear=True,
+    )
+    def test_url_without_scheme_rejected(self):
+        with pytest.raises(ValueError, match="HTTPS"):
+            Config.validate()
+
+    @mock.patch.dict(
+        os.environ,
+        {"REDMINE_URL": "ftp://red.eltex.loc/", "REDMINE_API_KEY": "token"},
+        clear=True,
+    )
+    def test_non_http_scheme_rejected(self):
+        with pytest.raises(ValueError, match="HTTPS"):
+            Config.validate()
+
+    @mock.patch.dict(
+        os.environ,
+        {"REDMINE_URL": "https://red.eltex.loc/", "REDMINE_API_KEY": "token"},
+        clear=True,
+    )
+    def test_https_url_accepted(self):
+        Config.validate()
+
+    @mock.patch.dict(
+        os.environ,
+        {"REDMINE_URL": "HTTPS://red.eltex.loc/", "REDMINE_API_KEY": "token"},
+        clear=True,
+    )
+    def test_uppercase_scheme_accepted(self):
+        Config.validate()
+
+
+# -- #57: предупреждение при отключённой проверке TLS --
+
+
+class TestWarnWhenTlsVerificationDisabled:
+    """verify_ssl: false должен давать видимый warning в stderr (риск MITM)."""
+
+    _ENV: ClassVar[dict[str, str]] = {
+        "REDMINE_URL": "https://red.eltex.loc/",
+        "REDMINE_API_KEY": "token",
+    }
+
+    def _validate_env(self, verify: str):
+        return {**self._ENV, "REDMINE_VERIFY": verify}
+
+    def test_verify_false_warns_in_stderr(self, capsys):
+        with mock.patch.dict(os.environ, self._validate_env("false"), clear=True):
+            Config.validate()
+
+        err = capsys.readouterr().err
+        assert "⚠️" in err
+        assert "TLS" in err or "SSL" in err
+
+    def test_verify_true_no_warning(self, capsys):
+        with mock.patch.dict(os.environ, self._validate_env("true"), clear=True):
+            Config.validate()
+
+        assert capsys.readouterr().err == ""
+
+    def test_verify_ca_path_no_warning(self, capsys):
+        with mock.patch.dict(
+            os.environ, self._validate_env("/tmp/redmine-ca.pem"), clear=True
+        ):
+            Config.validate()
+
+        assert capsys.readouterr().err == ""
+
+    def test_verify_default_no_warning(self, capsys):
+        with mock.patch.dict(os.environ, self._ENV, clear=True):
+            Config.validate()
+
+        assert capsys.readouterr().err == ""
+
+
 # -- #15: .env не должен переопределять переменные окружения --
 
 
-@mock.patch("dotenv.load_dotenv")
+@mock.patch("redmine_reporter.config.load_dotenv")
 def test_env_var_takes_priority_over_dotenv(mock_load):
     """load_dotenv вызывается с override=False — env vars не перебиваются .env."""
-    import importlib
-
-    from redmine_reporter import config as cfg_mod
-
-    importlib.reload(cfg_mod)
+    Config.load_yaml("/nonexistent/config.yml")
 
     mock_load.assert_called_once_with(override=False)
 
@@ -163,13 +365,7 @@ redmine:
   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"
+  from: "2026-06-01"
 
 output:
   dir: ~/reports
@@ -208,12 +404,7 @@ class TestAppConfigFromYaml:
             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.period_from == "2026-06-01"
             assert cfg.output_dir == "~/reports"
             assert cfg.output_filename == "{author}_{from}_{to}.{ext}"
             assert cfg.output_default_format == "xlsx"
@@ -236,7 +427,7 @@ class TestAppConfigFromYaml:
             assert cfg.redmine_url == "https://x.com/"
             # defaults for everything else
             assert cfg.redmine_author == ""
-            assert cfg.period_precision == "date"
+            assert cfg.period_from == ""
             assert cfg.output_dir == ""
             assert cfg.email.to == []
 
@@ -249,7 +440,36 @@ class TestAppConfigFromYaml:
 
             assert cfg.redmine_url == ""
             assert cfg.redmine_api_key == ""
-            assert cfg.period_precision == "date"
+            assert cfg.period_from == ""
+
+    def test_period_from_loaded_from_yaml(self):
+        """period.from читается из YAML как единственный ключ периода."""
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text("period:\n  from: '2026-06-01'\n")
+
+            cfg = AppConfig.from_yaml(yaml_path)
+
+            assert cfg.period_from == "2026-06-01"
+
+    def test_old_period_keys_are_ignored(self):
+        """Устаревшие ключи period молча игнорируются -- читается только from."""
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text(
+                "period:\n"
+                "  precision: datetime\n"
+                "  dynamic: true\n"
+                "  default_from: '2026-01-01'\n"
+                "  default_to: '2026-01-31'\n"
+                "  last_used:\n"
+                "    from: '2026-01-31T09:00:00'\n"
+                "    to: '2026-01-31T12:00:00'\n"
+            )
+
+            cfg = AppConfig.from_yaml(yaml_path)
+
+            assert cfg.period_from == ""
 
     def test_file_not_found_returns_all_defaults(self):
         cfg = AppConfig.from_yaml("/nonexistent/path/config.yml")
@@ -265,16 +485,57 @@ class TestAppConfigFromYaml:
 
             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."""
+    def test_verify_ssl_true_returns_true(self):
+        """verify_ssl: true → bool True (стандартная проверка TLS)."""
         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  # не бул!
+            assert cfg.redmine_verify is True
+
+    @pytest.mark.parametrize("value", ["true", "True", "yes", "on", "1"])
+    def test_verify_ssl_true_string_returns_true(self, value):
+        """Строковые true-значения в YAML → bool True, как и из env."""
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text(f"redmine:\n  verify_ssl: '{value}'\n")
+
+            cfg = AppConfig.from_yaml(yaml_path)
+
+            assert cfg.redmine_verify is True
+
+    def test_verify_ssl_custom_path_returns_path(self):
+        """Явный путь к CA-bundle в YAML передаётся как есть."""
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text("redmine:\n  verify_ssl: /etc/ssl/my-ca.pem\n")
+
+            cfg = AppConfig.from_yaml(yaml_path)
+
+            assert cfg.redmine_verify == "/etc/ssl/my-ca.pem"
+
+    @pytest.mark.parametrize("value", ["false", "False", "no", "off", "0"])
+    def test_verify_ssl_false_string_returns_false(self, value):
+        """Строковые false-значения в YAML → bool False."""
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text(f"redmine:\n  verify_ssl: '{value}'\n")
+
+            cfg = AppConfig.from_yaml(yaml_path)
+
+            assert cfg.redmine_verify is False
+
+    def test_verify_ssl_missing_returns_true(self):
+        """Без verify_ssl в YAML — проверка TLS включена (True)."""
+        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_verify is True
 
     def test_verify_ssl_false_returns_false(self):
         with tempfile.TemporaryDirectory() as tmp:
@@ -356,14 +617,15 @@ class TestConfigYamlFallback:
 
     @mock.patch.dict(os.environ, {}, clear=True)
     def test_date_range_from_yaml(self):
+        from datetime import date
+
         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"
-            )
+            yaml_path.write_text("period:\n  from: '2026-03-01'\n")
 
             Config._app = AppConfig.from_yaml(yaml_path)
 
+        with mock_today(date(2026, 3, 15)):
             assert Config.get_default_date_range() == "2026-03-01--2026-03-15"
 
     @mock.patch.dict(os.environ, {}, clear=True)
@@ -393,205 +655,19 @@ class TestConfigYamlFallback:
 
     @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"
-
-    @mock.patch.dict(os.environ, {}, clear=True)
-    def test_falls_back_to_today_when_default_to_missing(self):
-        """Если default_from задан, а default_to нет — конец периода сегодня."""
         from datetime import date
 
         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-04-01'\n"
-            )
+            yaml_path.write_text("period:\n  from: '2026-03-01'\n")
+
             Config._app = AppConfig.from_yaml(yaml_path)
-            today = date.today().isoformat()
-            result = Config.get_default_date_range()
-            assert result == f"2026-04-01--{today}"
+
+        with (
+            mock.patch.dict(os.environ, {"FROM_DATE": "2026-07-01"}, clear=True),
+            mock_today(date(2026, 7, 15)),
+        ):
+            assert Config.get_default_date_range() == "2026-07-01--2026-07-15"
 
 
 class TestGetEmailConfig:
@@ -730,3 +806,169 @@ class TestReportNoTime:
 
             Config._app = AppConfig.from_yaml(yaml_path)
             assert Config.get_report_no_time() is False
+
+
+# ---------------------------------------------------------------------------
+# #65: report.status_translation — перевод статусов из YAML
+# ---------------------------------------------------------------------------
+
+
+class TestStatusTranslationFromYaml:
+    """Tests for report.status_translation loading in AppConfig.from_yaml()."""
+
+    def test_status_translation_loaded_from_yaml(self):
+        """report.status_translation заполняет поле AppConfig (override + новый)."""
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text(
+                "report:\n"
+                "  status_translation:\n"
+                '    New: "Новая"\n'
+                '    "Custom Status": "Кастом"\n'
+            )
+
+            cfg = AppConfig.from_yaml(yaml_path)
+
+            assert cfg.report_status_translation == {
+                "New": "Новая",
+                "Custom Status": "Кастом",
+            }
+
+    def test_status_translation_missing_defaults_to_empty(self):
+        """Без секции report.status_translation поле пустое."""
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text("report:\n  no_time: true\n")
+
+            cfg = AppConfig.from_yaml(yaml_path)
+
+            assert cfg.report_status_translation == {}
+
+    def test_status_translation_non_mapping_warns_and_ignored(self, caplog):
+        """status_translation не-mapping (строка) → warning в лог, поле {}."""
+        import logging
+
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text("report:\n  status_translation: 'just a string'\n")
+
+            with caplog.at_level(logging.WARNING):
+                cfg = AppConfig.from_yaml(yaml_path)
+
+            assert cfg.report_status_translation == {}
+            assert "status_translation" in caplog.text
+
+    @mock.patch.dict(os.environ, {"STATUS_RU": "На проверке"}, clear=True)
+    def test_status_translation_env_var_resolved(self):
+        """${VAR} в значении перевода резолвится из окружения."""
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text(
+                "report:\n  status_translation:\n    Testing: ${STATUS_RU}\n"
+            )
+
+            cfg = AppConfig.from_yaml(yaml_path)
+
+            assert cfg.report_status_translation == {"Testing": "На проверке"}
+
+    def test_status_translation_null_value_skipped_with_warning(self, caplog):
+        """Значение null пропускается с warning, а не превращается в 'None'."""
+        import logging
+
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text(
+                "report:\n  status_translation:\n    New:\n    Closed: Закрыто\n"
+            )
+
+            with caplog.at_level(logging.WARNING):
+                cfg = AppConfig.from_yaml(yaml_path)
+
+            assert cfg.report_status_translation == {"Closed": "Закрыто"}
+            assert "status_translation" in caplog.text
+            assert "New" in caplog.text
+
+    def test_status_translation_nested_dict_skipped_with_warning(self, caplog):
+        """Вложенный dict в значении пропускается с warning, а не в repr."""
+        import logging
+
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text(
+                "report:\n"
+                "  status_translation:\n"
+                "    New:\n"
+                "      nested: value\n"
+                "    Closed: Закрыто\n"
+            )
+
+            with caplog.at_level(logging.WARNING):
+                cfg = AppConfig.from_yaml(yaml_path)
+
+            assert cfg.report_status_translation == {"Closed": "Закрыто"}
+            assert "status_translation" in caplog.text
+            assert "New" in caplog.text
+
+    def test_status_translation_int_value_coerced_to_str(self):
+        """Scalar-значения (int) по-прежнему приводятся к str."""
+        with tempfile.TemporaryDirectory() as tmp:
+            yaml_path = Path(tmp) / "config.yml"
+            yaml_path.write_text("report:\n  status_translation:\n    New: 42\n")
+
+            cfg = AppConfig.from_yaml(yaml_path)
+
+            assert cfg.report_status_translation == {"New": "42"}
+
+
+class TestGetStatusTranslation:
+    """Tests for Config.get_status_translation()."""
+
+    def test_no_yaml_returns_builtin(self):
+        """Без YAML-конфига возвращается встроенный словарь."""
+        from redmine_reporter.report_builder import STATUS_TRANSLATION
+
+        Config._app = None
+        try:
+            assert Config.get_status_translation() == STATUS_TRANSLATION
+        finally:
+            Config._app = None
+
+    def test_empty_overrides_returns_builtin(self):
+        """Пустые overrides — результат равен встроенному словарю."""
+        from redmine_reporter.report_builder import STATUS_TRANSLATION
+
+        Config._app = AppConfig()
+        try:
+            assert Config.get_status_translation() == STATUS_TRANSLATION
+        finally:
+            Config._app = None
+
+    def test_override_and_extend(self):
+        """Override существующего статуса + добавление нового."""
+        Config._app = AppConfig(
+            report_status_translation={"New": "Новая", "Custom Status": "Кастом"}
+        )
+        try:
+            translation = Config.get_status_translation()
+        finally:
+            Config._app = None
+
+        assert translation["New"] == "Новая"
+        assert translation["Custom Status"] == "Кастом"
+        # остальные встроенные переводы не тронуты
+        assert translation["Closed"] == "Закрыто"
+
+    def test_result_is_a_copy(self):
+        """Мутация результата не трогает модульный STATUS_TRANSLATION."""
+        from redmine_reporter.report_builder import STATUS_TRANSLATION
+
+        Config._app = AppConfig(report_status_translation={"New": "Новая"})
+        try:
+            translation = Config.get_status_translation()
+            translation["New"] = "ИЗМЕНЕНО"
+            translation["Junk"] = "мусор"
+        finally:
+            Config._app = None
+
+        assert STATUS_TRANSLATION["New"] == "В работе"
+        assert "Junk" not in STATUS_TRANSLATION

tests/test_formatters.py

@@ -1,6 +1,5 @@
 import io
 import json
-from typing import List
 from unittest import mock
 
 import pytest
@@ -25,7 +24,7 @@ def _make_empty_odt_bytes() -> bytes:
     return buf.getvalue()
 
 
-def make_fake_report_rows() -> List[ReportRow]:
+def make_fake_report_rows() -> list[ReportRow]:
     """
     Генерирует фейковый отчёт с полным покрытием логики группировки:
     - Проект A: версия v1.0 (2 задачи), версия v2.0 (1 задача)
@@ -396,6 +395,32 @@ def test_xlsx_has_totals(fake_rows, tmp_path):
     assert ws["F2"].number_format == "0.00"
 
 
+def test_xlsx_has_full_header_row_and_grand_total_row(fake_rows, tmp_path):
+    """XLSX содержит полный ряд заголовков колонок и финальную строку общего итога."""
+    from openpyxl import load_workbook
+
+    output = tmp_path / "report.xlsx"
+    XLSXFormatter().save(fake_rows, str(output))
+
+    wb = load_workbook(str(output))
+    ws = wb.active
+
+    headers = [ws.cell(row=1, column=c).value for c in range(1, 8)]
+    assert headers == [
+        "Project",
+        "Version",
+        "Issue ID",
+        "Subject",
+        "Status",
+        "Hours",
+        "Spent Time",
+    ]
+
+    # Последняя строка — общий итог по всем проектам
+    assert ws.cell(row=ws.max_row, column=1).value == "Total"
+    assert ws.cell(row=ws.max_row, column=6).value == 22.5
+
+
 def test_xlsx_no_time_keeps_columns_empty_and_skips_totals(fake_rows, tmp_path):
     """XLSX с no_time: колонки времени пустые, итогов нет."""
     from openpyxl import load_workbook
@@ -456,6 +481,25 @@ def test_html_output_has_doctype_and_charset(fake_rows):
     assert '<meta charset="utf-8">' in output
 
 
+def test_html_has_table_structure_with_all_columns(fake_rows):
+    """HTML-отчёт содержит thead со всеми колонками и по строке на каждую задачу."""
+    output = HTMLFormatter().format(fake_rows)
+
+    assert "<thead>" in output
+    assert "<tbody>" in output
+    for header in (
+        "Наименование Проекта",
+        "Номер версии*",
+        "Задача",
+        "Статус Готовность*",
+        "Затрачено за отчетный период",
+    ):
+        assert f"<th>{header}</th>" in output
+
+    tbody = output.split("<tbody>", 1)[1]
+    assert tbody.count("<tr>") == len(fake_rows)
+
+
 # -- Тесты ODT форматтера --
 
 

tests/test_import_side_effects.py

@@ -0,0 +1,50 @@
+"""#64: импорт модулей не должен давать side effects в процессе."""
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+
+
+def _run_in_subprocess(code: str, cwd: Path) -> str:
+    """Выполняет code в чистом интерпретаторе с доступом к пакету."""
+    env = {**os.environ, "PYTHONPATH": str(REPO_ROOT)}
+    result = subprocess.run(
+        [sys.executable, "-c", code],
+        cwd=cwd,
+        env=env,
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    return result.stdout.strip()
+
+
+def test_config_import_does_not_mutate_os_environ(tmp_path):
+    """import redmine_reporter.config не подгружает .env из текущей директории."""
+    (tmp_path / ".env").write_text("RR_IMPORT_PROBE=1\n")
+
+    output = _run_in_subprocess(
+        "import os\n"
+        "import redmine_reporter.config\n"
+        "print('RR_IMPORT_PROBE' in os.environ)\n",
+        cwd=tmp_path,
+    )
+
+    assert output == "False"
+
+
+def test_mailer_import_does_not_mutate_global_charset_registry(tmp_path):
+    """import redmine_reporter.mailer не меняет email.charset для всего процесса."""
+    output = _run_in_subprocess(
+        "from email.charset import BASE64, Charset\n"
+        "before = Charset('utf-8').body_encoding\n"
+        "import redmine_reporter.mailer\n"
+        "after = Charset('utf-8').body_encoding\n"
+        "print(before == BASE64, after == BASE64)\n",
+        cwd=tmp_path,
+    )
+
+    assert output == "True True"

tests/test_mailer.py

@@ -49,7 +49,37 @@ class TestBuildMessage:
         msg = build_message(cfg, "/tmp/report.xlsx", "Иванов", "Q1", [])
         plain_parts = [p for p in msg.walk() if p.get_content_type() == "text/plain"]
         assert len(plain_parts) == 1
-        assert "Автор: Иванов, период: Q1" in plain_parts[0].as_string()
+        payload = plain_parts[0].get_payload(decode=True).decode("utf-8")
+        assert "Автор: Иванов, период: Q1" in payload
+
+    def test_wire_format_is_8bit_utf8(self):
+        """Сериализация в байты (как в smtplib.send_message) — 8bit UTF-8."""
+        from email.generator import BytesGenerator
+        from io import BytesIO
+
+        cfg = _make_email_config(body_text="Автор: {author}", attach=False)
+        msg = build_message(cfg, "/tmp/r.xlsx", "Иванов", "Q1", [])
+
+        buf = BytesIO()
+        BytesGenerator(buf, policy=msg.policy.clone(linesep="\r\n")).flatten(msg)
+        data = buf.getvalue()
+
+        assert b"Content-Transfer-Encoding: 8bit" in data
+        assert "Автор: Иванов".encode() in data
+
+    def test_plain_part_uses_8bit_utf8(self):
+        """Тела письма кодируются 8bit UTF-8 (не base64), точечно на часть."""
+        cfg = _make_email_config(
+            body_text="Автор: {author}, период: {period}", attach=False
+        )
+        msg = build_message(cfg, "/tmp/r.xlsx", "Иванов", "Q1", [])
+
+        plain = next(p for p in msg.walk() if p.get_content_type() == "text/plain")
+        assert plain["Content-Transfer-Encoding"] == "8bit"
+        assert (
+            plain.get_payload(decode=True).decode("utf-8")
+            == "Автор: Иванов, период: Q1"
+        )
 
     def test_from_header(self):
         cfg = _make_email_config(from_="sender@example.com", attach=False)
@@ -175,7 +205,7 @@ class TestBuildMessage:
         ]
         msg = build_message(cfg, str(report), "A", "P", rows)
 
-        html_part = [p for p in msg.walk() if p.get_content_type() == "text/html"][0]
+        html_part = next(p for p in msg.walk() if p.get_content_type() == "text/html")
         payload = html_part.get_payload(decode=True).decode("utf-8")
         assert "Project X" in payload
         assert "Important task" in payload
@@ -198,9 +228,9 @@ class TestBuildMessage:
         ]
         msg = build_message(cfg, str(report), "A", "P", rows)
 
-        alternative = [
+        alternative = next(
             p for p in msg.walk() if p.get_content_type() == "multipart/alternative"
-        ][0]
+        )
         payloads = alternative.get_payload()
         assert payloads[0].get_content_type() == "text/plain"
         assert payloads[1].get_content_type() == "text/html"
@@ -243,8 +273,10 @@ class TestSendReport:
         report.write_text("fake content")
         cfg = _make_email_config()
 
-        with mock.patch("smtplib.SMTP", side_effect=OSError("Connection refused")):
-            with pytest.raises(RedmineAPIError, match="Не удалось подключиться к SMTP"):
+        with (
+            mock.patch("smtplib.SMTP", side_effect=OSError("Connection refused")),
+            pytest.raises(RedmineAPIError, match="Не удалось подключиться к SMTP"),
+        ):
             send_report(cfg, str(report), "A", "P", [])
 
     def test_send_auth_error(self, tmp_path):
@@ -267,8 +299,10 @@ class TestSendReport:
         report.write_text("fake content")
         cfg = _make_email_config()
 
-        with mock.patch("smtplib.SMTP", side_effect=TimeoutError()):
-            with pytest.raises(RedmineAPIError, match="Таймаут соединения с SMTP"):
+        with (
+            mock.patch("smtplib.SMTP", side_effect=TimeoutError()),
+            pytest.raises(RedmineAPIError, match="Таймаут соединения с SMTP"),
+        ):
             send_report(cfg, str(report), "A", "P", [])
 
     def test_send_generic_smtp_error(self, tmp_path):

tests/test_report_builder.py

@@ -277,3 +277,27 @@ def test_group_rows_preserves_row_data():
 def test_group_rows_empty():
     """Пустой список — пустой словарь."""
     assert group_rows_by_project_and_version([]) == {}
+
+
+# -- #65: кастомный перевод статусов --
+
+
+def test_build_grouped_report_custom_status_translation():
+    """status_translation переопределяет встроенный словарь (#65)."""
+    issue = MockIssue("P", "S", "New", "v1.0", 1)
+    rows = build_grouped_report([(issue, 1.0)], status_translation={"New": "Новая"})
+    assert rows[0]["status_ru"] == "Новая"
+
+
+def test_build_grouped_report_custom_status_translation_passthrough():
+    """Статус вне кастомного словаря возвращается как есть (#65)."""
+    issue = MockIssue("P", "S", "Closed", "v1.0", 1)
+    rows = build_grouped_report([(issue, 1.0)], status_translation={"New": "Новая"})
+    assert rows[0]["status_ru"] == "Closed"
+
+
+def test_build_grouped_report_none_translation_uses_builtin():
+    """status_translation=None — используется встроенный словарь (#65)."""
+    issue = MockIssue("P", "S", "Closed", "v1.0", 1)
+    rows = build_grouped_report([(issue, 1.0)], status_translation=None)
+    assert rows[0]["status_ru"] == "Закрыто"

tests/test_task_list.py

@@ -0,0 +1,350 @@
+"""Тесты доменного ядра режима --my-tasks (#71): строки, сортировка, саммари."""
+
+from datetime import date
+from unittest import mock
+
+from redmine_reporter.task_list import (
+    EXCLUDED_VERSION_NAMES,
+    PRIORITY_RANK,
+    build_task_rows,
+    calculate_task_summary,
+    filter_excluded_versions,
+    format_summary_line,
+    priority_rank,
+)
+
+TODAY = date(2026, 10, 28)
+
+
+def make_issue(
+    issue_id,
+    priority="P3",
+    status="New",
+    fixed_version=None,
+    subject="Задача",
+    due=None,
+    spent_hours=0.0,
+    estimated_hours=None,
+):
+    """Собирает mock-issue с nested-атрибутами priority.name / fixed_version.name.
+
+    fixed_version=None присваивается явно: unset-атрибут MagicMock был бы
+    автосконструирован, и getattr() вернул бы его вместо безопасного дефолта.
+    """
+    issue = mock.MagicMock()
+    issue.id = issue_id
+    issue.subject = subject
+    issue.status = status
+    issue.priority.name = priority
+    if fixed_version is None:
+        issue.fixed_version = None
+    else:
+        issue.fixed_version.name = fixed_version
+    issue.spent_hours = spent_hours
+    # None присваивается явно, чтобы getattr() в реализации не наткнулся
+    # на автосконструированный MagicMock-атрибут.
+    issue.estimated_hours = estimated_hours
+    return issue
+
+
+# -- Приоритеты --
+
+
+def test_priority_rank_table():
+    assert PRIORITY_RANK == {"P1": 1, "P2": 2, "P3": 3, "P4": 4, "P5": 5}
+
+
+def test_priority_rank_known():
+    assert priority_rank("P1") == 1
+    assert priority_rank("P5") == 5
+
+
+def test_priority_rank_unknown_is_lowest():
+    """Неизвестное имя приоритета получает ранг ниже P5."""
+    assert priority_rank("P9") == 6
+    assert priority_rank("") == 6
+
+
+def test_rows_sorted_by_priority():
+    """P1 раньше P2 раньше P4; неизвестный P9 -- после P5."""
+    items = [
+        (make_issue(4, priority="P4"), None),
+        (make_issue(9, priority="P9"), None),
+        (make_issue(2, priority="P2"), None),
+        (make_issue(5, priority="P5"), None),
+        (make_issue(1, priority="P1"), None),
+    ]
+    rows = build_task_rows(items, {}, today=TODAY)
+    assert [r["issue_id"] for r in rows] == [1, 2, 4, 5, 9]
+
+
+# -- Сортировка внутри приоритетной группы --
+
+
+def test_rows_due_ascending_within_priority():
+    items = [
+        (make_issue(2, priority="P2"), date(2026, 3, 10)),
+        (make_issue(1, priority="P2"), date(2026, 1, 1)),
+        (make_issue(3, priority="P2"), date(2026, 2, 15)),
+    ]
+    rows = build_task_rows(items, {}, today=TODAY)
+    assert [r["issue_id"] for r in rows] == [1, 3, 2]
+
+
+def test_rows_without_due_go_last_and_tiebreak_by_id():
+    """Задачи без срока -- в конец своей группы; между ними tie-break по id."""
+    items = [
+        (make_issue(25, fixed_version="v2"), None),  # версия есть, срока нет
+        (make_issue(30, fixed_version="v1"), date(2026, 2, 1)),
+        (make_issue(12), None),  # версии нет, срока нет
+    ]
+    rows = build_task_rows(items, {}, today=TODAY)
+    assert [r["issue_id"] for r in rows] == [30, 12, 25]
+
+
+# -- Фильтр версий-исключений (Wishlist) --
+
+
+def test_excluded_version_names_constant():
+    """Точный состав бакет-версий, исключаемых из --my-tasks."""
+    assert EXCLUDED_VERSION_NAMES == frozenset({"Wishlist"})
+
+
+def test_filter_excludes_wishlist_issue():
+    """Задача в версии Wishlist удаляется из выборки."""
+    items = [
+        (make_issue(1, fixed_version="Wishlist"), None),
+        (make_issue(2, fixed_version="v2.5.0"), date(2026, 11, 1)),
+    ]
+    kept = filter_excluded_versions(items)
+    assert [issue.id for issue, _ in kept] == [2]
+
+
+def test_filter_keeps_issue_without_version():
+    """Задача без версии фильтром не трогается."""
+    items = [(make_issue(3), None)]
+    kept = filter_excluded_versions(items)
+    assert [issue.id for issue, _ in kept] == [3]
+
+
+def test_filter_keeps_regular_version_without_due():
+    """Обычная версия без срока -- не бакет, задача остаётся."""
+    items = [(make_issue(4, fixed_version="v3.0.0"), None)]
+    kept = filter_excluded_versions(items)
+    assert [issue.id for issue, _ in kept] == [4]
+
+
+def test_filter_is_case_sensitive():
+    """Сравнение имени версии точное: wishlist строчными -- НЕ исключение."""
+    items = [
+        (make_issue(5, fixed_version="wishlist"), None),
+        (make_issue(6, fixed_version="WISHLIST"), None),
+        (make_issue(7, fixed_version="Wishlist"), None),
+    ]
+    kept = filter_excluded_versions(items)
+    assert [issue.id for issue, _ in kept] == [5, 6]
+
+
+def test_filter_returns_only_excluded_when_all_match():
+    items = [(make_issue(8, fixed_version="Wishlist"), None)]
+    assert filter_excluded_versions(items) == []
+
+
+def test_filter_preserves_due_pairing():
+    """Фильтр не теряет парную к задаче дату срока."""
+    due = date(2026, 12, 1)
+    items = [(make_issue(9, fixed_version="v1"), due)]
+    ((issue, kept_due),) = filter_excluded_versions(items)
+    assert issue.id == 9
+    assert kept_due is due
+
+
+def test_filter_tolerates_version_without_name_attribute():
+    """fixed_version без атрибута name -- задача остаётся (getattr-безопасность)."""
+    issue = make_issue(10)
+    issue.fixed_version = mock.MagicMock(spec=[])
+    items = [(issue, None)]
+    kept = filter_excluded_versions(items)
+    assert [i.id for i, _ in kept] == [10]
+
+
+# -- Просроченность --
+
+
+def test_overdue_yesterday():
+    rows = build_task_rows([(make_issue(1), date(2026, 10, 27))], {}, today=TODAY)
+    assert rows[0]["overdue"] is True
+
+
+def test_not_overdue_today():
+    """Срок сегодня -- НЕ просрочен (строгое сравнение)."""
+    rows = build_task_rows([(make_issue(1), date(2026, 10, 28))], {}, today=TODAY)
+    assert rows[0]["overdue"] is False
+
+
+def test_not_overdue_tomorrow():
+    rows = build_task_rows([(make_issue(1), date(2026, 10, 29))], {}, today=TODAY)
+    assert rows[0]["overdue"] is False
+
+
+def test_not_overdue_without_due():
+    rows = build_task_rows([(make_issue(1), None)], {}, today=TODAY)
+    assert rows[0]["overdue"] is False
+
+
+# -- Поля строки --
+
+
+def test_row_fields():
+    issue = make_issue(
+        42,
+        priority="P1",
+        status="New",
+        fixed_version="v2.5.0",
+        subject="Починить баг",
+    )
+    rows = build_task_rows([(issue, date(2026, 10, 27))], {}, today=TODAY)
+    row = rows[0]
+    assert row["issue_id"] == 42
+    assert row["subject"] == "Починить баг"
+    assert row["priority"] == "P1"
+    assert row["version_name"] == "v2.5.0"
+    assert row["due_text"] == "2026-10-27"
+    assert row["overdue"] is True
+
+
+def test_row_empty_version_and_due_text():
+    """Без версии и без срока в строке пустые строки, а не заглушки."""
+    rows = build_task_rows([(make_issue(7), None)], {}, today=TODAY)
+    assert rows[0]["version_name"] == ""
+    assert rows[0]["due_text"] == ""
+
+
+# -- Перевод статусов --
+
+
+def test_status_translated_by_dict():
+    issue = make_issue(1, status="New")
+    rows = build_task_rows([(issue, None)], {"New": "Новая"}, today=TODAY)
+    assert rows[0]["status_ru"] == "Новая"
+
+
+def test_status_unknown_passthrough():
+    issue = make_issue(1, status="SomeNewStatus")
+    rows = build_task_rows([(issue, None)], {"New": "Новая"}, today=TODAY)
+    assert rows[0]["status_ru"] == "SomeNewStatus"
+
+
+# -- Саммари --
+
+
+def test_summary_mixed_items():
+    """Смесь: без версии / версия без срока / просроченная / с оценками и без."""
+    items = [
+        # без версии, без срока, без оценки
+        (make_issue(1, spent_hours=1.5), None),
+        # версия есть, срока нет, оценка есть
+        (make_issue(2, fixed_version="v1", spent_hours=2.0, estimated_hours=4.0), None),
+        # просроченная, оценка есть
+        (
+            make_issue(3, fixed_version="v2", spent_hours=0.5, estimated_hours=3.0),
+            date(2026, 10, 27),
+        ),
+        # не просроченная, оценка None
+        (
+            make_issue(4, fixed_version="v3", spent_hours=0.0),
+            date(2026, 10, 29),
+        ),
+    ]
+    summary = calculate_task_summary(items, today=TODAY)
+
+    assert summary["total"] == 4
+    assert summary["overdue"] == 1
+    assert summary["no_version"] == 1
+    assert summary["no_due"] == 1
+    assert summary["spent_hours"] == 4.0
+    assert summary["estimated_hours"] == 7.0
+    assert summary["estimated_count"] == 2
+
+
+def test_summary_empty():
+    summary = calculate_task_summary([], today=TODAY)
+    assert summary == {
+        "total": 0,
+        "overdue": 0,
+        "no_version": 0,
+        "no_due": 0,
+        "spent_hours": 0.0,
+        "estimated_hours": 0.0,
+        "estimated_count": 0,
+    }
+
+
+def test_summary_missing_attributes_default_to_zero():
+    """У issue без атрибутов spent_hours/estimated_hours безопасные нули."""
+    issue = mock.MagicMock(spec=["id", "subject", "status", "priority"])
+    issue.id = 5
+    issue.status = "New"
+    issue.priority.name = "P3"
+
+    summary = calculate_task_summary([(issue, None)], today=TODAY)
+
+    assert summary["spent_hours"] == 0.0
+    assert summary["estimated_hours"] == 0.0
+    assert summary["estimated_count"] == 0
+    assert summary["no_version"] == 1
+    assert summary["no_due"] == 0
+
+
+# -- Строка саммари --
+
+
+def test_format_summary_line_with_estimates():
+    summary = {
+        "total": 4,
+        "overdue": 1,
+        "no_version": 1,
+        "no_due": 1,
+        "spent_hours": 4.0,
+        "estimated_hours": 7.0,
+        "estimated_count": 2,
+    }
+    line = format_summary_line(summary)
+    assert line == (
+        "Открытых: 4 | просроченных: 1 | без версии: 1 | без срока: 1 "
+        "| потрачено: 4h | оценка: 7h (по 2 из 4)"
+    )
+
+
+def test_format_summary_line_without_estimates():
+    summary = {
+        "total": 3,
+        "overdue": 0,
+        "no_version": 2,
+        "no_due": 1,
+        "spent_hours": 2.5,
+        "estimated_hours": 0.0,
+        "estimated_count": 0,
+    }
+    line = format_summary_line(summary)
+    assert "оценка" not in line
+    assert line == (
+        "Открытых: 3 | просроченных: 0 | без версии: 2 | без срока: 1 | потрачено: 2.5h"
+    )
+
+
+def test_format_summary_line_fractional_hours_use_g_format():
+    """Часы форматируются :g -- без хвостовых нулей."""
+    summary = {
+        "total": 1,
+        "overdue": 0,
+        "no_version": 0,
+        "no_due": 0,
+        "spent_hours": 21.5,
+        "estimated_hours": 7.25,
+        "estimated_count": 1,
+    }
+    line = format_summary_line(summary)
+    assert "21.5h" in line
+    assert "7.25h" in line
+    assert "21.500000" not in line

tests/test_task_table.py

@@ -0,0 +1,161 @@
+"""Тесты консольного форматтера таблицы режима --my-tasks (#71)."""
+
+import re
+from typing import cast
+
+import pytest
+
+from redmine_reporter.formatters.task_table import TaskTableFormatter
+from redmine_reporter.types import TaskRow
+
+BASE_URL = "https://red.eltex.loc"
+
+# OSC 8-гиперссылка: esc-последовательность до текста, текст, закрытие ссылки.
+OSC8_RE = re.compile(r"\x1b\]8;;[^\x1b]*\x1b\\")
+
+
+def make_row(**overrides) -> TaskRow:
+    row: TaskRow = {
+        "issue_id": 42,
+        "subject": "Починить баг",
+        "status_ru": "Новая",
+        "priority": "P2",
+        "version_name": "v2.5.0",
+        "due_text": "2026-10-15",
+        "overdue": False,
+    }
+    # **-распаковка dict[str, Any] в TypedDict-литерале mypy не поддерживает,
+    # а kwargs-словарь типизируется только как dict[str, Any], поэтому приведение.
+    row.update(cast(TaskRow, overrides))
+    return row
+
+
+def expected_hyperlink(issue_id, base_url=BASE_URL):
+    return f"\x1b]8;;{base_url}/issues/{issue_id}\x1b\\{issue_id}\x1b]8;;\x1b\\"
+
+
+# -- OSC 8-гиперссылка на ID --
+
+
+def test_id_wrapped_in_exact_osc8_sequence():
+    output = TaskTableFormatter(base_url=BASE_URL).format([make_row()])
+    assert expected_hyperlink(42) in output
+
+
+def test_base_url_trailing_slash_not_duplicated():
+    """base_url с завершающим слэшем не даёт двойного слэша перед /issues."""
+    output = TaskTableFormatter(base_url=BASE_URL + "/").format([make_row()])
+    assert expected_hyperlink(42) in output
+    assert "//issues/" not in output
+
+
+def test_hyperlink_text_is_issue_number_only():
+    """Текст ссылки -- только номер, тема не попадает внутрь OSC 8."""
+    output = TaskTableFormatter(base_url=BASE_URL).format(
+        [make_row(issue_id=7, subject="Тема задачи")]
+    )
+    assert expected_hyperlink(7) in output
+    assert "Тема задачи" in output
+    start = output.index("Тема задачи")
+    assert "\x1b" not in output[:start].replace(expected_hyperlink(7), "")
+
+
+def test_hyperlink_uses_row_issue_id():
+    output = TaskTableFormatter(base_url=BASE_URL).format([make_row(issue_id=1234)])
+    assert expected_hyperlink(1234) in output
+
+
+# -- Заполнение пустых полей --
+
+
+def test_empty_version_rendered_as_dash():
+    output = TaskTableFormatter(base_url=BASE_URL).format([make_row(version_name="")])
+    assert "-" in output
+
+
+def test_empty_due_rendered_as_dash():
+    output = TaskTableFormatter(base_url=BASE_URL).format([make_row(due_text="")])
+    assert "-" in output
+
+
+def test_nonempty_fields_not_replaced_by_dash():
+    output = TaskTableFormatter(base_url=BASE_URL).format([make_row()])
+    assert "v2.5.0" in output
+    assert "2026-10-15" in output
+
+
+# -- Маркер просрочки --
+
+
+def test_overdue_due_appends_marker():
+    output = TaskTableFormatter(base_url=BASE_URL).format(
+        [make_row(due_text="2026-10-15", overdue=True)]
+    )
+    assert "2026-10-15 (!)" in output
+
+
+def test_not_overdue_due_without_marker():
+    output = TaskTableFormatter(base_url=BASE_URL).format(
+        [make_row(due_text="2026-10-15", overdue=False)]
+    )
+    assert "2026-10-15" in output
+    assert "(!)" not in output
+
+
+# -- Заголовки и содержимое --
+
+
+def test_column_headers_present():
+    output = TaskTableFormatter(base_url=BASE_URL).format([make_row()])
+    for header in ("ID", "Тема", "Статус", "Приор.", "Версия", "Срок"):
+        assert header in output
+
+
+def test_status_passed_through_as_is():
+    """status_ru из TaskRow попадает в таблицу без изменений."""
+    output = TaskTableFormatter(base_url=BASE_URL).format(
+        [make_row(status_ru="В работе")]
+    )
+    assert "В работе" in output
+
+
+def test_subject_and_priority_present():
+    output = TaskTableFormatter(base_url=BASE_URL).format(
+        [make_row(subject="Обновить драйвер", priority="P1")]
+    )
+    assert "Обновить драйвер" in output
+    assert "P1" in output
+
+
+def test_multiple_rows_rendered():
+    rows = [make_row(issue_id=1), make_row(issue_id=2)]
+    output = TaskTableFormatter(base_url=BASE_URL).format(rows)
+    assert expected_hyperlink(1) in output
+    assert expected_hyperlink(2) in output
+
+
+def test_empty_rows_renders_headers_only():
+    output = TaskTableFormatter(base_url=BASE_URL).format([])
+    assert "ID" in output
+    assert expected_hyperlink(42) not in output
+
+
+# -- ESC только внутри ссылок --
+
+
+def test_esc_only_inside_hyperlinks():
+    """После вырезания OSC 8-ссылок в строке не остаётся ESC-символов."""
+    rows = [
+        make_row(issue_id=1),
+        make_row(issue_id=2, version_name=""),
+        make_row(issue_id=3, due_text="", overdue=True),
+    ]
+    output = TaskTableFormatter(base_url=BASE_URL).format(rows)
+    cleaned = OSC8_RE.sub("", output)
+    assert "\x1b" not in cleaned
+
+
+def test_save_raises_not_implemented():
+    formatter = TaskTableFormatter(base_url=BASE_URL)
+    with pytest.raises(NotImplementedError):
+        formatter.save([], "unused.xlsx")

tests/test_utils.py

@@ -110,3 +110,21 @@ def test_get_version_falls_back_to_str_when_no_name():
         fixed_version = MockVersionNoName()
 
     assert get_version(MockIssue()) == "fallback-id"
+
+
+def test_get_version_custom_default():
+    """Явный default заменяет <N/A>, когда версия не назначена."""
+
+    class MockIssue:
+        pass
+
+    assert get_version(MockIssue(), default="") == ""
+
+
+def test_get_version_custom_default_not_used_when_version_present():
+    """При наличии версии default не применяется."""
+
+    class MockIssue:
+        fixed_version = "v1.0"
+
+    assert get_version(MockIssue(), default="") == "v1.0"

tests/test_yaml_config.py

@@ -4,11 +4,14 @@ import tempfile
 from pathlib import Path
 from unittest import mock
 
+import yaml
+
 from redmine_reporter.yaml_config import (
     check_file_permissions,
     ensure_config_dir,
     expand_filename_template,
     resolve_env_vars,
+    save_period_to_config,
 )
 
 
@@ -211,120 +214,65 @@ class TestResolveOutputPath:
 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
-
+    def test_creates_period_from_in_empty_config(self, tmp_path):
         config_path = tmp_path / "config.yml"
-        save_period_to_config(
-            str(config_path), "2026-06-01", "2026-06-30", "date", True
-        )
+        config_path.write_text("")
+
+        save_period_to_config(str(config_path), "2026-06-01")
 
         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
+        assert data["period"]["from"] == "2026-06-01"
 
+    def test_overwrites_existing_period_from(self, tmp_path):
         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"
-        )
+        config_path.write_text("period:\n  from: '2026-05-01'\n")
 
-        save_period_to_config(
-            str(config_path), "2026-06-01", "2026-06-30", "date", True
-        )
+        save_period_to_config(str(config_path), "2026-06-01")
 
         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
+        assert data["period"]["from"] == "2026-06-01"
 
+    def test_preserves_other_sections_and_keys(self, tmp_path):
         config_path = tmp_path / "config.yml"
         config_path.write_text(
             "redmine:\n"
             "  url: https://example.com\n"
             "  author: Test\n"
+            "email:\n"
+            "  enabled: true\n"
             "output:\n"
             "  dir: /tmp\n"
         )
 
-        save_period_to_config(
-            str(config_path), "2026-06-01", "2026-06-30", "date", True
-        )
+        save_period_to_config(str(config_path), "2026-06-01")
 
         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"
+        assert data["redmine"] == {"url": "https://example.com", "author": "Test"}
+        assert data["email"] == {"enabled": True}
+        assert data["output"] == {"dir": "/tmp"}
+        assert data["period"] == {"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
-        )
+        save_period_to_config(str(config_path), "2026-06-01")
 
         mode = config_path.stat().st_mode & 0o777
         assert mode == 0o600
+
+    def test_creates_config_file_and_dir_when_missing(self, tmp_path):
+        config_path = tmp_path / "nested" / "config.yml"
+        assert not config_path.exists()
+
+        save_period_to_config(str(config_path), "2026-06-01")
+
+        assert config_path.exists()
+        with open(config_path) as fh:
+            data = yaml.safe_load(fh)
+        assert data["period"]["from"] == "2026-06-01"