add skill

clear
add zip
2026-08-21 23:03:44 +07:00 · 2026-08-21 00:09:32 +07:00 · 2026-08-20 23:17:52 +07:00 · 2026-08-20 03:27:26 +07:00 · 2026-08-20 02:31:14 +07:00 · 2026-08-20 00:17:30 +07:00
90 changed files with 10664 additions and 900 deletions
@@ -9,7 +9,7 @@ steps:
      - set GOOS=linux
      - set GOARCH=amd64
      - set CGO_ENABLED=0
-      - go build -a -ldflags '-extldflags "-static"' -o evening_detective_server cmd/evening_detective_server/main.go
+      - go build -a -ldflags '-extldflags "-static"' -o evening_detective_server ./cmd/evening_detective_server
  - name: test
    image: golang
@@ -0,0 +1,94 @@
 ---
 name: create-go-module
 description: Создаёт Go-модуль в internal/modules/<snake_case>/ по конвенциям репозитория — обязательный interface.go с интерфейсом (имя начинается с I) и всеми публичными типами, в папке как минимум одна реализация интерфейса (неэкспортируемая структура + конструктор New*, возвращающий интерфейс). Загружай при создании нового модуля или заготовки модуля.
 whenToUse: Пользователь просит создать модуль/компонент/сервис/заготовку в internal/modules, либо «сделать по конвенциям проекта», либо явно упоминает interface.go или интерфейс с префиксом I.
 ---
 # Создание Go-модуля (internal/modules)
 ## Контекст
 В этом проекте переиспользуемые компоненты живут в `internal/modules/<имя>/` — по одному модулю на папку. Публичный контракт модуля описывается в **обязательном** файле `interface.go`. Эталонные примеры действующих модулей: `internal/modules/password_generator`, `internal/modules/email_sender`, `internal/modules/cleaner`, `internal/modules/storytelling`, `internal/modules/processor_jwt`.
 ## Обязательные правила
 1. **Папка модуля** — `internal/modules/<snake_case>/` (например, `email_sender`). Имя Go-пакета равно имени папки. Никаких вложенных подпакетов внутри модуля.
 2. **Файл `interface.go` обязателен.** В нём живёт ВЕСЬ публичный контракт модуля:
   - интерфейс(ы) модуля;
   - публичные типы: структуры-данные (DTO), перечисления, константы, именованные ошибки.
   Ничего другого (реализация, приватные хелперы) в этом файле нет.
 3. **Имя интерфейса начинается с `I`** — `I<CamelCase>`, например `IEmailSender`, `IPasswordGenerator`, `ICleaner`, `IStory`. Интерфейс без префикса `I` — недопустимо. В интерфейсе — только сигнатуры методов, без полей.
 4. **Реализация — в отдельном файле** (например, `<короткое_имя>.go` или `service.go`): неэкспортируемая структура (строчная, например `type emailSender struct`), методы которой реализуют интерфейс, и конструктор `func New<CamelCase>(...) I<CamelCase>`, возвращающий **интерфейс**, а не структуру.
 5. **В папке модуля — как минимум одна реализация интерфейса.** Модуль не может состоять из одного `interface.go`: рядом с ним всегда лежит неэкспортируемая структура, реализующая `I<CamelCase>` (см. правило 4), и конструктор, возвращающий интерфейс. Если реализаций несколько — каждая в своём файле.
 6. **Сигнатуры методов**: операции с внешним миром (сеть, файлы, БД, таймеры) принимают `context.Context` первым аргументом и возвращают `error`; чистые вычисления — без контекста (пример: `Generate() (string, error)` у `password_generator`).
 7. **Комментарии — на русском.** Каждый публичный идентификатор имеет doc-комментарий, начинающийся с имени символа. Пояснения сложных мест — тоже по-русски.
 8. **Ошибки** оборачиваются через `fmt.Errorf("<snake_case>: ...: %w", err)` — префикс с именем модуля.
 9. **JSON-теги** у сериализуемых структур — `json:"..."` (эталон: `storytelling/interface.go`).
 10. **Зависимости между модулями**: вместо импорта чужого модуля объявляется минимальный локальный интерфейс в файле `dependency.go` (эталон: `internal/modules/storytelling/dependency.go` объявляет собственный `ICleaner`). Это исключает циклические импорты и связывает модули только через их интерфейсы.
 11. **Тесты** — для модуля желателен файл `*_test.go` рядом с реализацией (примеры: `email_sender/sender_test.go`, `cleaner/service_test.go`).
 ## Шаги
 1. **Определи имя модуля.** Если имя неоднозначно — уточни у пользователя. Приведи имя к двум формам:
   - snake_case — папка и пакет: «генератор паролей» → `password_generator`;
   - CamelCase — имена типов и интерфейса: `PasswordGenerator` → `IPasswordGenerator`.
 2. **Создай папку** `internal/modules/<snake_case>/`.
 3. **Напиши `interface.go`** (обязательно): сначала публичные типы/константы, затем интерфейс `I<CamelCase>`.
 4. **Напиши файл(ы) реализации** (обязательно, минимум один) — неэкспортируемая структура + конструктор `New<CamelCase>(...) I<CamelCase>`.
 5. **При необходимости** добавь `dependency.go` (локальные интерфейсы зависимостей) и `*_test.go`.
 6. **Проверь сборку** из корня проекта: `go build ./...` и `go vet ./...`. Ошибки — исправь.
 ## Шаблон interface.go
 ```go
 package <snake_case>
 import "context"
 // <TypeName> — описание публичного типа.
 type <TypeName> struct {
 	Field string `json:"field"`
 }
 // I<CamelCase> — контракт модуля <snake_case>.
 type I<CamelCase> interface {
 	// <Method> — описание метода.
 	<Method>(ctx context.Context, in <TypeName>) error
 }
 ```
 ## Шаблон реализации
 ```go
 package <snake_case>
 import (
 	"context"
 	"fmt"
 )
 // <lowerCamelCase> — реализация I<CamelCase>.
 type <lowerCamelCase> struct {
 	// внутренние поля
 }
 // New<CamelCase> создаёт реализацию I<CamelCase>.
 func New<CamelCase>(...) I<CamelCase> {
 	return &<lowerCamelCase>{}
 }
 func (s *<lowerCamelCase>) <Method>(ctx context.Context, in <TypeName>) error {
 	// TODO: реализация
 	return fmt.Errorf("<snake_case>: не реализовано")
 }
 ```
 ## Критерии готовности
 - [ ] Папка `internal/modules/<snake_case>/` создана, имя пакета равно имени папки.
 - [ ] `interface.go` существует; все публичные типы, константы и интерфейсы описаны именно в нём.
 - [ ] Имя интерфейса начинается с `I`.
 - [ ] В папке модуля есть как минимум одна реализация интерфейса (неэкспортируемая структура + конструктор).
 - [ ] Реализация неэкспортируемая; конструктор возвращает интерфейс, а не структуру.
 - [ ] doc-комментарии на русском у всех публичных идентификаторов.
 - [ ] `go build ./...` и `go vet ./...` проходят без ошибок.
@@ -0,0 +1,115 @@
 ---
 name: task-execution
 description: Выполняет любую нетривиальную задачу по процессу «план → ревью сеньёром → правки → выполнение → ревью результата → правки». План и результат проверяет субагент в роли senior developer; каждый цикл повторяется, пока замечаний не останется. При неясностях агент задаёт вопросы пользователю. Загружай для реализации фичи, исправления бага, рефакторинга, написания кода или документации, когда задача не сводится к одному тривиальному действию.
 whenToUse: Пользователь просит выполнить задачу (написать код, починить баг, отрефакторить, задокументировать, что-то исследовать и внедрить) и задача не является тривиальным одношаговым действием. Для тривиальных правок скил можно не применять.
 ---
 # Выполнение любой задачи: план → сеньёр → выполнение → сеньёр
 ## Контекст
 Любая нетривиальная задача выполняется строго по циклу: сначала **план**, затем **ревью плана сеньёром** с правками до полного одобрения, затем **выполнение** по одобренному плану, затем **ревью результата сеньёром** с правками, пока замечаний не останется. На каждом этапе, если что-то неясно, задаются вопросы пользователю.
 ## Роли
 - **Исполнитель** — ты (агент). Составляешь план, выполняешь, правишь по замечаниям.
 - **Сеньёр (senior developer)** — отдельный субагент, запускаемый через `subagent`. Он **не видит наш диалог**, поэтому каждый промпт ревью должен быть самодостаточным: включай в него всю необходимую информацию (задачу, план, критерии, предыдущие замечания).
 - **Пользователь** — источник требований и финальный судья. Ему задаются вопросы при неясностях.
 ## Обязательные правила
 1. **Сначала план — потом выполнение.** Не начинай выполнение, пока сеньёр не одобрил план (ответил `APPROVED`).
 2. **Ревью плана и результата — только через субагента в роли senior developer** (см. шаблоны промптов ниже). Запускай его с `run_in_background: false` — следующий шаг зависит от его ответа.
 3. **Замечания исправляются все, без выбора.** Нельзя отбрасывать замечание «потому что не согласен»: если не согласен — верни уточняющий вопрос сеньёру или спроси пользователя.
 4. **Цикл повторяется, пока сеньёр не вернёт `APPROVED`** — и для плана, и для результата.
 5. **Неясно — спроси.** На любом этапе (задача, шаг плана, замечание сеньёра) при неоднозначности задай вопрос пользователю через `ask_user_question`. Догадки вместо вопросов — ошибка.
 6. **Отслеживай прогресс** через `todo_write`: план из шага 2 переносится в todo-список, пункты отмечаются по мере выполнения.
 7. **Профильные скилы** (например `create-go-module`) — источник правил «как делать» для конкретной задачи. Этот скил управляет процессом «как вести задачу»; оба применяются вместе.
 ## Шаги
 ### 1. Уточни задачу
 Разберись, что именно нужно сделать. Если неясны цель, объём, ограничения или критерии приёмки — задай вопросы пользователю до составления плана.
 ### 2. Составь план
 План должен содержать:
 - **Цель** и ожидаемый результат;
 - **Шаги** с конкретными файлами, командами и артефактами;
 - **Проверки** (сборка, тесты, линтеры, вёрстка и т.п.);
 - **Критерии готовности** — что считается «сделано»;
 - **Риски и открытые вопросы** (если есть).
 Заведи todo-список через `todo_write` в соответствии с планом.
 ### 3. Ревью плана сеньёром
 Запусти субагента с промптом по шаблону **«Ревью плана»** (ниже). Сеньёр возвращает либо `APPROVED`, либо список замечаний.
 ### 4. Цикл правок плана
 - Есть замечания → исправь план (и todo-список), отправь на ревью **повторно**: в промпт добавь предыдущие замечания и что именно изменилось.
 - Повторяй, пока не получишь `APPROVED`.
 ### 5. Выполнение
 Выполняй строго по одобренному плану, отмечая прогресс в `todo_write`. Если в ходе выполнения стало ясно, что план нужно изменить — не отклоняйся молча: вернись к шагу 3 с обновлённым планом.
 ### 6. Ревью результата
 Сначала сам проверь результат (прогони проверки из плана), затем отдай его сеньёру по шаблону **«Ревью результата»**. Сеньёр сверяет результат с планом и критериями, проверяет корректность и соблюдение конвенций проекта.
 ### 7. Цикл правок результата
 Правь по замечаниям, повторяй ревью, пока сеньёр не вернёт `APPROVED`. При каждом повторе сообщай сеньёру, что изменилось с прошлого раза.
 ### 8. Финальный отчёт
 Кратко сообщи пользователю: что сделано, какие файлы затронуты, как проверялось, что план и результат одобрены сеньёром.
 ## Шаблон: промпт «Ревью плана»
 ```
 Ты — senior developer. Оцени план выполнения задачи.
 Задача: <текст задачи>
 План: <план>
 Критерии готовности: <критерии>
 Проверь: полноту (нет ли пропущенных шагов), достижимость, корректность
 подхода, риски, соответствие конвенциям проекта, отсутствие лишних шагов.
 Ответь СТРОГО одним из двух вариантов:
 - APPROVED — если замечаний нет;
 - список замечаний, каждое в формате «<что не так> → <как исправить>».
 ```
 ## Шаблон: промпт «Ревью результата»
 ```
 Ты — senior developer. Оцени результат выполнения задачи.
 Задача: <текст задачи>
 План: <план>
 Критерии готовности: <критерии>
 Результат: <что сделано: файлы, изменения, выводы проверок>
 Проверь: результат соответствует плану и критериям готовности, код/текст
 корректен, соблюдены конвенции проекта, нет регрессий.
 Ответь СТРОГО одним из двух вариантов:
 - APPROVED — если замечаний нет;
 - список замечаний, каждое в формате «<что не так> → <как исправить>».
 ```
 ## Ограничение итераций
 Если в одном цикле (план или результат) после **5 раундов** замечания не исчерпались — остановись и спроси пользователя: продолжать цикл или зафиксировать оставшиеся замечания как известные ограничения.
 ## Критерии готовности
 - [ ] План составлен и одобрен сеньёром (`APPROVED`) до начала выполнения.
 - [ ] Все замечания сеньёра по плану учтены.
 - [ ] Результат соответствует плану и критериям готовности.
 - [ ] Все замечания сеньёра по результату учтены, получен `APPROVED`.
 - [ ] Пользователю дан финальный отчёт.
@@ -4,9 +4,20 @@ SMTP_HOST=mail.crabs-games.art
 SMTP_PORT=465
 SMTP_USER=evening_detective@crabs-games.art
 SMTP_PASSWORD=your_password
 # Отображаемое имя отправителя: Gmail показывает его вместо голого адреса,
 # письма от «имени» выглядят человечнее и реже попадают в спам
 SMTP_FROM_NAME=Вечерний детектив
 # Адрес, на который пользователь сможет ответить на письмо
 SMTP_REPLY_TO=evening_detective@crabs-games.art
 # Общий таймаут SMTP-диалога (dial + auth + отправка), дефолт 10s
 SMTP_TIMEOUT=10s
 JWT_SECRET=your_secret
 # Публичный адрес фронтенда: используется для ссылки «Войти в игру» в
 # письмах. Если не задан или не http(s) — ссылка в письма не добавляется.
 APP_BASE_URL=https://evening-detective.crabs-games.art
 S3_HOST=http://0.0.0.0:9000
 S3_USER=rustfs
 S3_PASSWORD=your_password
@@ -27,6 +27,10 @@ go.sum
 .env
 # Локальные Go-кэши (используются, когда системный кэш недоступен)
 .gocache/
 .gotmp/
 .VSCodeCounter/
 docker-compose-prod.yml
@@ -10,7 +10,7 @@ generate:
      ./api/main.proto
 run:
-	go run ./cmd/evening_detective_server/main.go
+	go run ./cmd/evening_detective_server
 build-builder:
 	docker build -f Dockerfile.builder -t my-go-builder .
@@ -20,7 +20,7 @@ build-linux:
 		-v "$$PWD":/app \
 		-w /app \
 		my-go-builder sh -c \
-		"GOOS=linux GOARCH=arm64 go build -o bin/evening_detective_server cmd/evening_detective_server/main.go"
+		"GOOS=linux GOARCH=arm64 go build -o bin/evening_detective_server ./cmd/evening_detective_server"
 test:
 	go test -count=1 ./...
@@ -38,3 +38,34 @@ goose -dir ./migrations postgres "user=postgres password=postgres host=localhost
 ```shell
 make test
 ```
 ## Документация и юридические документы
 - [`docs/TERMS.md`](docs/TERMS.md) — Пользовательское соглашение (оферта); раздаётся сервером по постоянному URL `/api/terms`;
 - [`docs/PRIVACY.md`](docs/PRIVACY.md) — Политика конфиденциальности и обработки персональных данных (152-ФЗ); раздаётся сервером по постоянному URL `/api/privacy`;
 - [`docs/CONSENT.md`](docs/CONSENT.md) — текст согласия на обработку ПДн для формы регистрации (URL `/api/consent`);
 - [`docs/COMPLIANCE.md`](docs/COMPLIANCE.md) — чек-лист приведения сервиса в соответствие с документами.
 Юридические эндпоинты:
 - `POST /api/auth/signup` — регистрация; требует `accept_terms: true` и `accept_privacy: true` (факт акцепта фиксируется в таблице `user_agreements`);
 - `DELETE /api/auth/delete-account` — удаление учётной записи и персональных данных (авторизован JWT, подтверждение паролем в HTTP-заголовке `X-Password`).
 ## Агент «Юрист по ПО» (DSH)
 В каталоге [`agents/software-lawyer`](agents/software-lawyer) лежит агент-пресет для DeepSeek Harness: специализированный консультант по правовым вопросам разработки ПО (лицензии, авторские права, персональные данные 152-ФЗ/GDPR, договоры). Отвечает на основе встроенной базы знаний (`skills/software-law/references/`), без внешних API.
 Установка (копирует пресет в `~/.dsh/.agent-presets/software-lawyer`):
 ```shell
 ./agents/software-lawyer/install.sh
 ```
 После установки пресет «Юрист по ПО» появится в списке агентов при создании новой сессии в веб-интерфейсе DSH. Повторная установка с перезаписью: `./agents/software-lawyer/install.sh --force`.
 Структура:
 - `agent.cordis.yml` — композиция агента (полный набор инструментов, как у пресета `standard`, + персона юриста и скилл-база);
 - `preset.yml` — отображаемое имя и описание;
 - `skills/software-law/` — база знаний: `SKILL.md` (правила консультаций) и `references/` (лицензии, авторские права, ПДн, договоры).
@@ -0,0 +1,277 @@
 # The `software-lawyer` agent preset: the full coding agent (tools identical to
 # `standard`) with the persona and knowledge base of «Юрист по ПО» — a legal
 # consultant for software development, licensing, copyright, personal data and
 # contracts. Mounted once per process.
 #
 # This file is an AGENT-PLANE composition. The roster mounts it ONCE under a
 # standing scope; every session naming it joins by scope parentage, so the
 # tools and prompt sections registered here cover each joined agent while a
 # session's own state stays keyed per Session/Agent inside the plugins. The
 # host composition (`base.cordis.yml` + `web.cordis.yml`) keeps everything a
 # preset must not own: the registries themselves, the sandbox and approval
 # stack, persistence, and the model route.
 #
 # A service row here MUST sit inside a group carrying an `isolate` realm.
 # Without one it publishes into the root realm, where it is process-global —
 # another preset publishing the same name collides, and a host reader would
 # resolve one preset's instance for every session; `dsh-agent-presets` rejects
 # that at mount. `true` means an entry-local realm: this standing mount's own
 # private instance, apart from every other preset's. (A shared label does NOT
 # pool instances — `provide()` throws on the second registration under the
 # same realm symbol; labels join REALMS, and are not what this file needs.)
 # ── identity ────────────────────────────────────────────────────────────────
 # The preset's own persona, shadowing the deployment default for this agent.
 # `{{model}}` and `{{cwd}}` resolve from the agent's own route and workspace.
 - id: persona
  name: '@deepseek-ai/dsh-persona'
  config:
    text: |-
      You are «Юрист по ПО» (Software Lawyer) — специализированный агент-консультант по правовым вопросам разработки и распространения программного обеспечения, powered by the {{model}} model. Your working directory is {{cwd}}.
      ## Специализация
      - Лицензирование ПО: свободные и проприетарные лицензии (MIT, BSD, Apache-2.0, GPL-2.0/3.0, LGPL, AGPL, MPL, EPL, CC, Unlicense), совместимость лицензий, соблюдение их условий, compliance-риски при использовании сторонних компонентов.
      - Авторские права на код и базы данных: Бернская конвенция, ГК РФ часть 4 (глава 70), US Copyright Act, служебные произведения, передача и отчуждение прав, fair use.
      - Персональные данные: 152-ФЗ, GDPR, трансграничная передача данных, обработка данных в продуктах (cookies, аналитика, SaaS).
      - Договоры: разработка ПО, лицензионные договоры, SLA, NDA, escrow.
      ## Правила работы
      1. Перед ответом на юридический вопрос загрузи скилл `software-law` и прочитай нужный справочный файл из `references/` этого скилла (licenses.md, copyright.md, personal-data.md, contracts.md). Отвечай на основе этой базы знаний, а не по памяти.
      2. Структурируй ответ: краткий ответ → применимые нормы → анализ → вывод и рекомендации.
      3. Всегда добавляй дисклеймер: консультация носит информационный характер, не является юридической услугой и не заменяет профессиональную помощь; для юридически значимых решений нужно обратиться к квалифицированному юристу.
      4. Различай юрисдикции: право РФ / ЕС (GDPR) / США. Если юрисдикция не указана — уточни у пользователя.
      5. Если вопрос касается текущего репозитория (go.mod, лицензии зависимостей, условия), сначала изучи реальные файлы инструментами файловой системы и только потом отвечай.
      6. Ссылайся на конкретные нормы (например, ст. 1225–1231, 1235, 1261, 1295 ГК РФ; ст. 3–9, 12, 22 152-ФЗ; ст. 3, 6, 7, 15–22, 33–35, 83 GDPR) и условия лицензий. Не выдумывай ссылки; если не уверен в норме — так и скажи.
      7. Отвечай на языке пользователя (по умолчанию — русский).
 - id: agent-instructions
  name: '@deepseek-ai/dsh-agent-instructions'
  config:
    maxBytes: 65536
 # ── shell ───────────────────────────────────────────────────────────────────
 # `shell-env` stays in the HOST composition: `apps/cli/src/web.ts` injects it to
 # publish `DSH_WEB_URL`/`DSH_WEB_MODE`, and a host row that injects a service is
 # the criterion for host-plane ownership — injection resolves before any session
 # exists, so there is no agent to key by. Behind a preset realm those variables
 # never reached the model's shell at all. Both shell tools consume the host
 # registry from here; their executors (`bash-sandbox`/`pwsh-sandbox`) are
 # host-plane too.
 - id: tool-bash
  name: '@deepseek-ai/dsh-tool-bash'
  disabled: !!js process.platform === 'win32'
 - id: tool-pwsh
  name: '@deepseek-ai/dsh-tool-pwsh'
  disabled: !!js process.platform !== 'win32'
 # ── filesystem ──────────────────────────────────────────────────────────────
 # Both register into the host `tools` registry and provide nothing, so
 # they need no realm. The `fs` service and its policy stay in the host.
 - id: tool-fs
  name: '@deepseek-ai/dsh-tool-fs'
 - id: tool-fs-search
  name: '@deepseek-ai/dsh-tool-fs-search'
  config:
    sampleOverCapGlobResults: false
 # ── background jobs ────────────────────────────────────────────────────────
 # Only the model-facing controls. The task REGISTRY stays on the host plane:
 # its producers sit outside any realm this file could put it in — `tool-bash`
 # above resolves it with `ctx.get`, and an entry-local realm here is invisible
 # to every sibling row, so `run_in_background` would answer "background jobs
 # unavailable" while these controls sat in the catalog. The registry is keyed by
 # owning agent anyway, so one host instance serves every session. What a preset
 # chooses is whether its agent can collect and stop background work at all.
 - id: tool-jobs
  name: '@deepseek-ai/dsh-tool-jobs'
 # ── skills ──────────────────────────────────────────────────────────────────
 # The skill REGISTRY lives in the host composition and is layered per scope:
 # these rows register into THIS preset's layer of it, so they need no realm.
 # `skill-filesystem` contributes local-root discovery for agents on this preset, and
 # `tool-skill` gives them the catalog and loader; the merged catalog also
 # carries whatever the deployment registered globally (repository plugins).
 # The `software-law` knowledge base ships inside this preset: `customSkillDirs`
 # points the provider at the preset's own `skills/` directory, so the skill
 # travels with the composition wherever it is installed.
 - id: skill-filesystem
  name: '@deepseek-ai/dsh-skill-filesystem'
  config:
    customSkillDirs:
      - !!js "process.getBuiltinModule('node:url').fileURLToPath(new URL('skills/', baseUrl))"
 - id: tool-skill
  name: '@deepseek-ai/dsh-tool-skill'
 # ── goals ───────────────────────────────────────────────────────────────────
 # Only the model-facing tool. The goal SERVICE, its session driver, and the
 # `/goal` command stay on the host plane: the Gateway serves the goal domain as
 # Remote endpoints whose receiver comes from a generated descriptor, so it
 # resolves `goals` on the host and an entry-local realm here would hide it. The
 # registry is keyed by session anyway, so one host instance serves every
 # session. What a preset chooses is whether its agent can call the goal tool.
 - id: tool-goal
  name: '@deepseek-ai/dsh-tool-goal'
 # ── plan mode ───────────────────────────────────────────────────────────────
 # Plan state is per-agent by nature, so an entry-local realm is not a
 # workaround here — it is the correct lifetime.
 - id: planning
  name: cordis:group
  group: true
  isolate:
    planMode: true
  config:
    - id: plan-mode
      name: '@deepseek-ai/dsh-plan-mode'
      config:
        section: |
              You are in plan mode. Stay in plan mode until exit_plan_mode succeeds or the user switches the session mode. Imperative language to implement changes means plan the implementation, not execute it. A user's conversational agreement — including an answer confirming something you asked — approves nothing and does not end plan mode; fold the confirmed decision into the plan and submit it through exit_plan_mode.
              Explore first. Use non-mutating reads, searches, static analysis, and checks to ground the plan in the actual repository. Do not edit or write files, change configuration, run formatters or code generation that rewrites tracked files, commit, or otherwise carry out the plan. Prefer existing functions and patterns over new machinery.
              The tool catalog stays the same across modes for request-cache stability. These plan-mode rules override any later tool description or guidance that suggests using mutation tools; those tools remain listed to keep the tool catalog unchanged. Do not use todo_write to track this planning phase: it tracks implementation after an approved plan, while the plan itself belongs in exit_plan_mode.
              Resolve discoverable facts by inspection. Use ask_user_question only for user-owned choices or material ambiguity that inspection cannot answer. Do not ask the user where code lives or how current behavior works when you can find out.
              Make the plan decision-complete: state the goal and success criteria; group implementation changes by subsystem; identify public API, schema, and data-flow changes; cover edge cases, failure modes, tests, acceptance criteria, and explicit assumptions. Keep it concise enough to review but detailed enough that another engineer can implement it without making design decisions.
              When ready, call exit_plan_mode with the complete plan markdown, starting with a # title. Make exit_plan_mode the only and final tool call in that assistant response: it presents the plan for approval, and implementation begins only in a later step after approval. Do not paste the final plan as a plain reply or ask "should I proceed?" through prose or ask_user_question. If review rejects it, incorporate the feedback and present again. If the review channel is unavailable or aborted, stay in plan mode and ask the user to switch modes manually; do not proceed with implementation.
 # ── compaction ──────────────────────────────────────────────────────────────
 # `compaction-basic` reads `toolResultPrune` through `ctx.get`, so the pruner must
 # share this realm rather than sit outside it.
 #
 # `tokenMeter` is deliberately NOT in this realm: the meter stays on the HOST
 # plane, and the rows here resolve that one instance. It takes no configuration,
 # keys every fold by Session, and owns the context-meter projection units the
 # browser reads for every session — behind a realm those units would come and go
 # with whichever presets happen to be mounted. What a preset chooses is whether
 # its agent compacts at all, which is `compaction-basic` below.
 - id: compaction
  name: cordis:group
  group: true
  isolate:
    compaction: true
    toolResultPruner: true
  config:
    - id: compaction-basic
      name: '@deepseek-ai/dsh-compaction-basic'
    - id: command-compact
      name: '@deepseek-ai/dsh-command-compact'
    - id: tool-result-pruner
      name: '@deepseek-ai/dsh-compaction-tool-result-pruner'
      config:
        thresholdChars: 8192
        headChars: 4096
        tailChars: 1024
 # ── delegation and workflows ────────────────────────────────────────────────
 # The `subagents` registry and its spawn/fork backends live in the HOST
 # composition: the registry is a process singleton whose cross-session queries
 # the api-proxy serves to the browser, and a provider name may only be
 # registered once. This preset contributes the delegation TOOLS, which resolve
 # that host registry.
 #
 # `workflows` is different — nothing outside an agent reads it — so every row
 # that reaches it shares one entry-local realm here, and a consumer left
 # outside would resolve a host registry this preset does not populate.
 #
 # `tool-subagent-report` is host-plane for the same reason as the registry,
 # not because a preset may not want it: it registers a CONTINUABLE SETUP on
 # that singleton rather than a tool this agent calls, and the setup list is
 # not scope-aware — one copy per mounted preset means every child gets
 # `report` registered once per live session, which throws on the second.
 - id: delegation
  name: cordis:group
  group: true
  isolate:
    workflowEngine: true
  config:
    - id: tool-subagent-control
      name: '@deepseek-ai/dsh-tool-subagent-control'
    - id: tool-subagent-list-agents
      name: '@deepseek-ai/dsh-tool-subagent-control/list-agents'
    - id: tool-subagent
      name: '@deepseek-ai/dsh-tool-subagent'
      config:
        provider: spawn
        toolName: subagent
        backgroundMode: continuable
    - id: tool-subagent-fork
      name: '@deepseek-ai/dsh-tool-subagent'
      config:
        provider: fork
        toolName: subagent_fork
        backgroundMode: continuable
    # Product providers are host-plane singletons. Copy this preset, then
    # remove `disabled` from either ordinary tool row to expose that product
    # only to agents composed from the copy.
    - id: tool-subagent-codex
      name: '@deepseek-ai/dsh-tool-subagent'
      disabled: true
      config:
        provider: codex
        toolName: subagent_codex
        enableRunInBackground: false
        maxDepth: provider-managed
    - id: tool-subagent-claude-code
      name: '@deepseek-ai/dsh-tool-subagent'
      disabled: true
      config:
        provider: claude-code
        toolName: subagent_claude_code
        enableRunInBackground: false
        maxDepth: provider-managed
    - id: workflow-worker-thread
      name: '@deepseek-ai/dsh-workflow-worker-thread'
      config:
        provider: spawn
    - id: tool-workflow
      name: '@deepseek-ai/dsh-tool-workflow'
    - id: tool-ralph
      name: '@deepseek-ai/dsh-tool-ralph'
      config:
        subagentProvider: spawn
        maxRounds: 64
 # ── remaining model-facing rows ─────────────────────────────────────────────
 - id: tool-ask-user
  name: '@deepseek-ai/dsh-tool-ask-user'
 - id: tool-todo
  name: '@deepseek-ai/dsh-tool-todo'
  config:
    allowParallelInProgress: true
 # The `web` service and its search provider stay in the host composition; only
 # the model-facing tool is per-session.
 - id: tool-web
  name: '@deepseek-ai/dsh-tool-web'
  config:
    fetch: false
    searchTimeoutMs: 60000
@@ -0,0 +1,58 @@
 #!/usr/bin/env bash
 #
 # Устанавливает агента-пресет «Юрист по ПО» в пользовательский корень
 # пресетов DeepSeek Harness ($DSH_HOME/.agent-presets/software-lawyer).
 #
 # Использование:
 #   ./agents/software-lawyer/install.sh          # установка (идемпотентно)
 #   ./agents/software-lawyer/install.sh --force  # перезаписать существующий пресет
 #
 # После установки пресет «Юрист по ПО» появляется в списке агентов при
 # создании новой сессии (обнаружение пресетов читает каталог при каждом
 # вызове, перезапуск не требуется).
 set -euo pipefail
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 SOURCE_DIR="$SCRIPT_DIR"
 DSH_HOME="${DSH_HOME:-$HOME/.dsh}"
 TARGET_DIR="$DSH_HOME/.agent-presets/software-lawyer"
 FORCE=0
 for arg in "$@"; do
  case "$arg" in
    --force|-f) FORCE=1 ;;
    -h|--help)
      sed -n '2,14p' "$0" | sed 's/^# \{0,1\}//'
      exit 0
      ;;
    *) echo "Неизвестный аргумент: $arg" >&2; exit 2 ;;
  esac
 done
 if [[ -d "$TARGET_DIR" && "$FORCE" -ne 1 ]]; then
  echo "Пресет уже установлен: $TARGET_DIR"
  echo "Для перезаписи запустите с --force."
  exit 0
 fi
 mkdir -p "$DSH_HOME/.agent-presets"
 if [[ -d "$TARGET_DIR" ]]; then
  rm -rf "$TARGET_DIR"
 fi
 mkdir -p "$TARGET_DIR"
 # Копируем содержимое пресета, исключая сам скрипт установки.
 shopt -s dotglob
 for entry in "$SOURCE_DIR"/*; do
  [[ "$(basename "$entry")" == "install.sh" ]] && continue
  cp -R "$entry" "$TARGET_DIR"/
 done
 shopt -u dotglob
 # Пресет-каталоги в DSH создаются с правами владельца (0o700/0o600); копия
 # наследует umask — приведём к аналогичному виду.
 chmod -R u+rwX,go-rwx "$TARGET_DIR"
 echo "Установлено: $TARGET_DIR"
 echo "Пресет «Юрист по ПО» доступен при создании новой сессии."
@@ -0,0 +1,2 @@
 name: Юрист по ПО
 description: Агент-консультант по правовым вопросам разработки ПО — лицензии (MIT, GPL, Apache...), авторские права, персональные данные (152-ФЗ/GDPR), договоры. Отвечает на основе встроенной базы знаний, без внешних API.
@@ -0,0 +1,38 @@
 ---
 name: software-law
 description: База знаний агента «Юрист по ПО» — правила проведения юридических консультаций по разработке ПО и справочные материалы (лицензии, авторские права, персональные данные, договоры). Загружай перед ответом на любой юридический вопрос.
 ---
 # База знаний «Юрист по ПО»
 Это встроенная база знаний агента «Юрист по ПО» (движок: знания + правила, без внешних API). Справочные материалы лежат в `references/` этого скилла. Перед ответом на юридический вопрос прочитай соответствующий файл (или несколько) и строй ответ на его содержании.
 ## Справочные файлы
 | Тема вопроса | Файл |
 |---|---|
 | Лицензии ПО, совместимость, open source, compliance | `references/licenses.md` |
 | Авторские права на код, служебные произведения, передача прав | `references/copyright.md` |
 | Персональные данные: 152-ФЗ, GDPR, cookies, трансграничная передача | `references/personal-data.md` |
 | Договоры разработки, лицензионные договоры, SLA, NDA, escrow | `references/contracts.md` |
 ## Как проводить консультацию
 1. **Определи вопрос и юрисдикцию.** Если не указана (РФ / ЕС / США / иная) — уточни. Многие ответы радикально различаются по юрисдикциям.
 2. **Прочитай нужный справочный файл.** При комплексном вопросе — несколько файлов. Не отвечай «по памяти»: база знаний — источник истины.
 3. **Если вопрос касается конкретного проекта** (go.mod, зависимости, README, условия в репозитории) — сначала изучи реальные файлы инструментами файловой системы.
 4. **Структура ответа:**
   - краткий прямой ответ (1–3 предложения);
   - применимые нормы и условия (со ссылками на статьи/пункты);
   - анализ применительно к ситуации пользователя;
   - вывод и практические рекомендации (что сделать, что проверить, к кому обратиться).
 5. **Всегда добавляй дисклеймер:** консультация информационная, не является юридической услугой и не заменяет профессиональную помощь; для юридически значимых решений — к квалифицированному юристу.
 6. **Не выдумывай нормы.** Ссылайся только на то, что есть в справочных файлах или в проверенных источниках. Если нормы нет в базе — скажи, что вопрос требует уточнения у юриста.
 7. **Различай уровни уверенности.** Если норма спорная или зависит от обстоятельств — покажи оба прочтения и что влияет на вывод.
 ## Границы компетенции
 - Агент не подписывает документы, не даёт заключений «для суда», не представляет интересы в органах.
 - Шаблоны договоров/согласий — только информационный материал, требующий адаптации юристом.
 - Законы и практика меняются: при значимом решении проверяй актуальность норм (например, web_search).
 - Налоги, уголовная ответственность, регистрация юрлиц — вне специализации; перенаправь к профильному специалисту.
@@ -0,0 +1,65 @@
 # Договоры в разработке ПО
 Справочник агента «Юрист по ПО»: договоры разработки, лицензионные договоры, SLA, NDA, escrow.
 ## Договор разработки ПО (подряд/услуги)
 - **Квалификация**: разработка «под ключ» с результатом — договор подряда (гл. 37 ГК РФ) или смешанный; поддержка и сопровождение — возмездное оказание услуг (гл. 39 ГК РФ); для IT-проектов часто смешанный договор.
 - **Существенные условия**:
  - предмет: что разрабатывается (ТЗ/спецификация/приложение — обязательное приложение), объём, функциональные требования;
  - сроки: этапы, промежуточные и финальный сроки, порядок сдачи-приёмки;
  - цена и порядок оплаты (аванс/вехи/финальный платёж);
  - права на результаты (см. ниже) и на исходный код;
  - гарантии и ответственность сторон.
 - **Приёмка**: акт сдачи-приёмки, порядок тестирования, срок на замечания, последствия несоответствия (устранение за счёт исполнителя).
 - **Права на результат**: по умолчанию по договору подряда — у подрядчика (автора), заказчик получает право использования для целей договора (ст. 1296 ГК РФ — по договору подряда/заказа на создание программы: исключительное право принадлежит подрядчику, если договором не установлено иное; заказчик вправе использовать для целей договора). → **Договор должен явно передавать исключительное право или лицензию заказчику** (ст. 1234/1235 ГК РФ).
 - **Гарантии качества**: гарантийный срок, скрытые недостатки, техническая поддержка после сдачи.
 - **Ответственность**: неустойка за просрочку (ст. 330 ГК РФ), ограничение ответственности (cap), исключение косвенных убытков.
 ## Лицензионный договор (ст. 1235 ГК РФ)
 - **Существенные условия**: предмет (произведение/ПО), **способы использования** (обязательно! иначе право не считается предоставленным — ст. 1235 п. 2).
 - **Территория**: по умолчанию — вся территория РФ; можно указать иную.
 - **Срок**: до 5 лет, если не указан; можно бессрочно/до 5 лет.
 - **Вознаграждение**: форма (паушальное/роялти/смешанное); для возмездного договора цена существенна (ст. 1235 п. 5 — при отсутствии условия о вознаграждении договор считается незаключённым).
 - **Виды** (ст. 1236): простая (неисключительная) лицензия — правообладатель может лицензировать другим; исключительная — лицензиат единственный.
 - **Сублицензия** (ст. 1238): только с письменного согласия лицензиара, если не указано иное.
 - **Открытая лицензия** (ст. 1286.1) — упрощённый порядок акцепта, см. licenses.md.
 - **End User License Agreement (EULA)**: договор присоединения (ст. 428 ГК РФ); акцепт при установке/использовании (ст. 1286 п. 3 ГК РФ — допускается заключение путём совершения конклюдентных действий).
 ## SLA (Service Level Agreement)
 - Часть договора услуг/поддержки: **метрики** (uptime %, время ответа, время восстановления RTO), **периоды измерения**, **порядок расчёта**, **штрафы/компенсации** (service credits), исключения из SLA (форс-мажор, плановые окна, действия клиента).
 - Соотношение с гарантиями: SLA — операционные обязательства, не замена гарантий качества.
 - Типичные метрики: доступность (99.9%), MTTR, MTBF, время реакции по уровням приоритета инцидентов.
 ## NDA (соглашение о конфиденциальности)
 - **Предмет**: какая информация конфиденциальна (перечень/критерии), исключения (публичная информация, известная ранее, полученная от третьих лиц, разработанная самостоятельно).
 - **Обязательства**: неразглашение, ограничение использования, защита (разумные меры), возврат/уничтожение информации.
 - **Срок**: период действия + срок конфиденциальности после прекращения (обычно 2–5 лет).
 - **Одностороннее/двустороннее**: зависит от того, кто раскрывает информацию.
 - В РФ: ст. 1465–1470 ГК РФ (коммерческая тайна), 98-ФЗ «О коммерческой тайне».
 ## Escrow (депонирование исходного кода)
 - Третья сторона (эскроу-агент) хранит исходный код и документацию; заказчик получает доступ при наступлении условий (банкротство/прекращение поддержки вендора, неисполнение обязательств).
 - Применимо для критичных систем при закрытом коде вендора.
 - Условия: состав депозита, порядок обновления, условия и процедура раскрытия, ответственность эскроу-агента.
 ## Международные договоры
 - Выбор права и суда/арбитража (важно для кросс-граничных контрактов).
 - Инкотермс — для поставок (не для ПО как услуги).
 - Экспортный контроль (в т.ч. криптография — экспортные ограничения США (EAR), ЕС) — при распространении ПО за рубеж.
 - Налоговые аспекты (роялти, постоянное представительство) — вне специализации, направить к профильному специалисту.
 ## Чек-лист договора разработки
 1. Предмет + ТЗ/спецификация как приложение.
 2. Этапы, сроки, порядок приёмки.
 3. Права на код и результаты — явная передача заказчику.
 4. Гарантии, SLA (если поддержка), ответственность и cap.
 5. Конфиденциальность (NDA).
 6. Порядок расторжения и передача при прекращении (передача кода, данных).
 7. Право и юрисдикция.
@@ -0,0 +1,57 @@
 # Авторские права на программное обеспечение
 Справочник агента «Юрист по ПО»: охрана кода, служебные произведения, передача прав, ответственность.
 ## Основы
 - **Программа для ЭВМ** охраняется авторским правом как литературное произведение (ст. 1261 ГК РФ). Охраняется код (исходный и объектный), а также подготовительные материалы.
 - **База данных** — составное произведение (ст. 1260 ГК РФ); также охраняется право изготовителя базы данных (ст. 1333–1336 ГК РФ).
 - **Авторское право возникает автоматически** с момента создания произведения — без регистрации, без депонирования (ст. 1257, 1259 ГК РФ). Регистрация программ для ЭМВ возможна в Роспатенте (ст. 1262 ГК РФ) — добровольная, даёт презумпцию авторства и удобна в спорах.
 - **Международная охрана**: Бернская конвенция об охране литературных и художественных произведений (РФ — участник) — охрана без формальностей во всех странах-участницах.
 - **США**: US Copyright Act (17 U.S.C.), регистрация в U.S. Copyright Office — условие для statutory damages; fair use (§ 107).
 ## Объекты и права
 - **Личные неимущественные права автора** (ст. 1255, 1265 ГК РФ): право авторства, право на имя, неприкосновенность произведения, обнародование. Непередаваемы.
 - **Исключительное право** (ст. 1270 ГК РФ): использование произведения любым способом — воспроизведение, распространение, публичный показ, переработка (модификация кода!), доведение до всеобщего сведения (интернет) и др.
 - **Срок действия**: вся жизнь автора + 70 лет (ст. 1281 ГК РФ); в США — 70 лет после смерти автора (для работ по найму — 95 лет от публикации / 120 лет от создания).
 ## Служебные произведения (ст. 1295 ГК РФ)
 - Произведение, созданное **в пределах трудовых обязанностей** работника — исключительное право принадлежит **работодателю**, если договором не предусмотрено иное.
 - Автор (работник) вправе получить вознаграждение за использование (если не установлено иное).
 - Работодатель вправе обнародовать произведение и использовать его; автор не вправе препятствовать.
 - **Важно**: если код написан работником вне трудовых обязанностей (в свободное время, без задания) — по умолчанию права у работника. Границы спорны; решается по факту (должностная инструкция, характер работы).
 ## Произведения по заказу и по госконтракту
 - **По договору авторского заказа** (ст. 1288–1290 ГК РФ): права на произведение принадлежат автору, если договором не предусмотрена передача заказчику; договор должен прямо предусматривать отчуждение исключительного права или лицензию.
 - **По государственному/муниципальному контракту** (ст. 1298 ГК РФ): исключительное право принадлежит исполнителю, если контрактом не установлено иное (обычно — РФ/субъекту, если прямо указано).
 ## Передача и распоряжение правами
 - **Договор об отчуждении исключительного права** (ст. 1234 ГК РФ): переход права целиком; существенные условия — предмет (произведение) и цена (если безвозмездно — прямо указать).
 - **Лицензионный договор** (ст. 1235 ГК РФ): предоставление права использования в пределах (способы, территория, срок). Существенные условия: предмет, способы использования. Срок — до 5 лет, иначе 5 лет; территория — РФ, иначе вся территория РФ. Если способ использования не указан — право не считается предоставленным.
 - **Открытая лицензия** (ст. 1286.1 ГК РФ) — см. licenses.md.
 - **Простая/исключительная лицензия** (ст. 1236 ГК РФ): неисключительная (можно лицензировать другим) vs исключительная (лицензиат — единственный).
 - Форма: лицензионный договор — письменная, кроме открытых лицензий и лицензий на ПО для ЭВМ (ст. 1286 ГК РФ — допускается заключение путём акцепта условий, например при установке). Договор отчуждения исключительного права — письменный (ст. 1234).
 ## Свободное использование и fair use
 - **РФ** (ст. 1273–1280 ГК РФ): узкий перечень — личное использование, цитирование, использование для целей обучения/исследования (в установленных пределах) и др. Для ПО свободное использование практически не работает.
 - **США** (fair use, §107 Copyright Act): 4 фактора — цель/характер использования, характер произведения, объём использованного, влияние на рынок. Применяется в США, в РФ аналога нет.
 - **Реверс-инжиниринг**: в РФ ограниченно (ст. 1280 ГК РФ — право на декомпиляцию для взаимодействия программ, при определённых условиях); в ЕС — Directive 2009/24/EC (интероперабельность); в США — ограниченные исключения.
 ## Ответственность за нарушение (РФ)
 - Гражданско-правовая (ст. 1252, 1301 ГК РФ): требование о прекращении нарушения, изъятие контрафакта, **компенсация** — от 10 000 до 5 000 000 ₽ либо двукратная стоимость права использования или контрафактных экземпляров.
 - Административная (ст. 7.12 КоАП РФ): штрафы + конфискация.
 - Уголовная (ст. 146 УК РФ): крупный/особо крупный размер — штраф до 1 млн ₽, обязательные/принудительные работы, лишение свободы до 6 лет.
 - Плагиат (ст. 146 УК РФ ч. 1) — присвоение авторства.
 ## Практические вопросы
 - **Кто автор кода в команде?** Все, кто вносил творческий вклад; распределение прав — договором/соглашением.
 - **Стартапы**: закреплять права на код за компанией договорами с разработчиками (трудовой договор + положение о служебных произведениях, договоры подряда/заказа с исполнителями, соглашения об отчуждении прав от фрилансеров).
 - **Вклад в open source**: контрибьютор сохраняет права на свой вклад, лицензируя его под лицензией проекта (по умолчанию — лицензия репозитория); CLA (Contributor License Agreement) — договор, перераспределяющий/лицензирующий права в пользу проекта.
 - **AI-сгенерированный код**: правовой статус не устоялся; в ряде юрисдикций (США, ЕС) результаты генерации без творческого вклада человека могут не охраняться; РФ — доктринально спорно, практика формируется. Рекомендовать: фиксировать в договорах права на AI-результаты, проверять условия инструментов генерации.
@@ -0,0 +1,98 @@
 # Лицензии программного обеспечения
 Справочник агента «Юрист по ПО». Лицензия — правовой инструмент, определяющий, как можно использовать, изменять и распространять ПО. В РФ лицензии на ПО оформляются как лицензионные договоры, в т.ч. открытые лицензии (ст. 1286.1 ГК РФ).
 ## Базовые понятия
 - **Проприетарная лицензия** — права ограничены: обычно запрет копирования, модификации, реверс-инжиниринга, субаренды; часто оплата за использование.
 - **Open source (OSI)** — ПО с лицензией, удовлетворяющей 10 критериям OSI (свободное распространение, доступность исходников, право на модификацию и производные и т.д.).
 - **Свободное ПО (FSF)** — 4 свободы: запускать для любых целей, изучать и изменять, распространять копии, распространять улучшенные версии.
 - **SPDX-идентификатор** — стандартный короткий код лицензии (например `MIT`, `Apache-2.0`, `GPL-3.0-only`), используется в метаданных зависимостей и отчётах.
 ## Пермиссивные лицензии (permissive)
 Разрешают почти всё (использование, модификацию, закрытие исходников, включение в проприетарный продукт) при соблюдении условий атрибуции.
 | Лицензия | SPDX | Ключевые условия | Особенности |
 |---|---|---|---|
 | MIT | `MIT` | Сохранение уведомления об авторстве и текста лицензии в копиях/производных | Самая простая и распространённая; совместима практически со всем |
 | BSD-2-Clause | `BSD-2-Clause` | Атрибуция, запрет использования имени автора для рекламы | |
 | BSD-3-Clause | `BSD-3-Clause` | Как BSD-2 + запрет использования имени автора в рекламе без разрешения | |
 | ISC | `ISC` | Атрибуция | Похожа на MIT, короче |
 | Apache-2.0 | `Apache-2.0` | Атрибуция + уведомление об изменениях (NOTICE), явная патентная лицензия | Патентная «граната»: грант патентов на вклад; совместима с GPL-3.0 |
 | Unlicense / CC0 | `Unlicense` / `CC0-1.0` | Отказ от прав (public domain по возможности) | CC0 — не для ПО в РФ напрямую (нет института public domain); Unlicense — текст-отказ |
 **Вывод для проприетарного продукта:** пермиссивные лицензии безопасны — можно включить код в закрытый продукт, выполнив условия атрибуции (обычно копия текста лицензии + уведомление об авторстве в составе дистрибутива).
 ## Копилефт-лицензии (copyleft)
 Требуют, чтобы производные работы распространялись под той же лицензией (с открытием исходников).
 | Лицензия | SPDX | Обязательство | Особенности |
 |---|---|---|---|
 | GPL-2.0 | `GPL-2.0-only` | Производные работы — под GPL-2.0 с открытием исходников | Классический «сильный» копилефт; несовместима с Apache-2.0 |
 | GPL-3.0 | `GPL-3.0-only` | Как GPL-2.0 + явная патентная лицензия, защита от TiVo-зации (антиблокировка) | Совместима с Apache-2.0; несовместима с GPL-2.0 (можно под «GPL-2.0-or-later» объединять) |
 | LGPL-2.1 / LGPL-3.0 | `LGPL-2.1-only` / `LGPL-3.0-only` | Копилефт для самой библиотеки; использование через динамическую компоновку не «заражает» вызывающий код | Слабее GPL: проприетарное приложение может использовать LGPL-библиотеку динамически |
 | AGPL-3.0 | `AGPL-3.0-only` | Как GPL-3.0 + обязательство открытия исходников при предоставлении ПО через сеть (SaaS) | Критична для серверных продуктов и веб-сервисов |
 | MPL-2.0 | `MPL-2.0` | Копилефт на уровне файлов: изменённые файлы — под MPL, остальное можно под другой лицензией | «Слабый» копилефт; файловый уровень; совместима с GPL |
 | EPL-2.0 | `EPL-2.0` | Копилефт на уровне модуля; патентный грант | Используется Eclipse Foundation |
 **Ключевые риски:**
 - Включение GPL/AGPL-кода в проприетарный продукт обычно **недопустимо** без открытия исходников продукта под GPL.
 - **AGPL** опасна для SaaS: использование AGPL-кода в серверной части веб-сервиса обязывает открыть исходники сервиса (при передаче через сеть).
 - **LGPL + статическая компоновка / копирование кода** может «заразить» продукт; динамическая компоновка (shared library) обычно безопасна.
 - **Копирование кода** (copy-paste) из copyleft-проекта = создание производной работы со всеми последствиями.
 ## Лицензии Creative Commons (для контента, не для ПО)
 - `CC0-1.0` — отказ от прав (public domain).
 - `CC-BY-4.0` — атрибуция.
 - `CC-BY-SA-4.0` — атрибуция + share-alike (производные под той же лицензией).
 - `CC-BY-NC-*` — запрет коммерческого использования.
 - `CC-BY-ND-*` — запрет производных работ.
 - **Не рекомендуется для ПО** (нет чётких правил для кода, нет патентных положений); для кода лучше CC0 (отказ) или MIT.
 ## Совместимость лицензий (кратко)
 | Комбинация | Совместимо? |
 |---|---|
 | MIT/BSD/ISC + любая лицензия | Да |
 | Apache-2.0 + GPL-3.0 | Да (Apache-2.0 совместима с GPL-3.0) |
 | Apache-2.0 + GPL-2.0 | Нет |
 | GPL-2.0 + GPL-3.0 | Нет (если не «or-later») |
 | GPL + LGPL | Да (LGPL-код можно включать в GPL-проект) |
 | MPL-2.0 + GPL | Да |
 | GPL + проприетарный продукт | Только если продукт открывается под GPL |
 | AGPL + проприетарный SaaS | Нет (по умолчанию) |
 ## Dual licensing (двойное лицензирование)
 Правообладатель предлагает выбор: например, open source-лицензия (GPL/AGPL) ИЛИ коммерческая лицензия. Пользователь выбирает одну. Частая модель для библиотек (пример: MySQL, Qt, MongoDB).
 ## Проверка лицензий зависимостей (compliance)
 - **SPDX-метаданные** в go.mod / package.json / Cargo.toml и т.д.
 - Инструменты: `go-licenses`, `license-checker` (npm), `cargo-license`, FOSSA, ScanCode Toolkit, GitHub Dependency Insights.
 - В отчёте фиксировать: компонент, версия, SPDX-идентификатор, текст лицензии, совместимость с моделью распространения продукта.
 - Атрибуция: собрать THIRD_PARTY_NOTICES / NOTICE с текстами лицензий и уведомлениями об авторстве.
 ## Открытая лицензия в РФ (ст. 1286.1 ГК РФ)
 - Открытая лицензия — лицензионный договор, заключаемый в упрощённом порядке (акцепт условий, например началом использования).
 - Действует на всей территории мира, на срок действия исключительного права, если не указано иное.
 - Лицензиар вправе отказаться от договора в одностороннем порядке, если лицензиат предоставляет третьим лицам права на ПО (например, сублицензии) в нарушение условий.
 - Для ПО открытые лицензии (MIT, GPL и т.д.) признаются в РФ лицензионными договорами.
 ## Ответственность и риски
 - Нарушение условий лицензии = нарушение исключительного права (ст. 1252, 1301 ГК РФ): компенсация от 10 000 до 5 000 000 ₽ или двукратная стоимость права использования / контрафактных экземпляров; также возможны изъятие контрафакта, судебные запреты.
 - Для иностранных правообладателей — Бернская конвенция обеспечивает охрану в РФ.
 - Ответственность за отсутствие лицензионной чистоты (license hygiene) ложится на распространителя продукта.
 ## Чек-лист для ответа про лицензии
 1. Какой компонент и какая лицензия (SPDX)?
 2. Как используется: включение кода, компоновка (динамическая/статическая), сервис (SaaS)?
 3. Как распространяется продукт: закрытый, open source, под какой лицензией?
 4. Есть ли патентные положения (Apache-2.0, GPL-3.0) и патентные риски?
 5. Выполнены ли условия атрибуции и доставлен ли текст лицензии?
@@ -0,0 +1,58 @@
 # Персональные данные в ПО: 152-ФЗ и GDPR
 Справочник агента «Юрист по ПО»: обработка персональных данных (ПДн) в продуктах, сервисах и приложениях.
 ## Основные понятия (152-ФЗ)
 - **Персональные данные (ПДн)** (ст. 3): любая информация, относящаяся к прямо или косвенно определённому или определяемому физическому лицу (субъекту ПДн).
 - **Оператор**: государственный орган, юрлицо или физлицо, организующее/осуществляющее обработку ПДн.
 - **Обработка**: любое действие с ПДн — сбор, запись, систематизация, накопление, хранение, уточнение, извлечение, использование, передача, обезличивание, блокирование, удаление, уничтожение.
 - **Специальные категории** (ст. 10): раса, национальность, политические взгляды, религия, здоровье, интимная жизнь. Обработка — только в исключительных случаях.
 - **Биометрические ПДн** (ст. 11): обработка — только с согласия в письменной форме (кроме гос. систем).
 ## Принципы и основания (152-ФЗ)
 - **Принципы** (ст. 5): законность и справедливость; соответствие целям; минимизация; точность; достаточность; ограничение сроков хранения.
 - **Основания обработки** (ст. 6): согласие субъекта; исполнение договора; исполнение закона; защита жизни/здоровья; исполнение полномочий госорганов; законные интересы оператора (с учётом прав субъекта).
 - **Согласие** (ст. 9): конкретное, информированное, сознательное; может быть в любой форме, позволяющей подтвердить факт получения; отзыв — в любое время; при отзыве оператор обязан прекратить обработку и уничтожить ПДн, если нет иных оснований.
 ## Обязанности оператора (152-ФЗ)
 - **Уведомление Роскомнадзора** о намерении обрабатывать ПДн (ст. 22) — до начала обработки, кроме случаев из ч. 2 ст. 22 (трудовые отношения, договоры с субъектом, одноразовый пропуск, без использования средств автоматизации и т.д.).
 - **Локальные акты** (ст. 18.1): политика обработки ПДн, положение/инструкции, назначение ответственного, оценка вреда, меры безопасности.
 - **Меры безопасности** (ст. 19): правовые, организационные и технические меры (шифрование, разграничение доступа, антивирус, защита каналов).
 - **Права субъекта** (ст. 14): доступ к своим ПДн, уточнение, блокирование, уничтожение, обжалование действий оператора.
 - **Трансграничная передача** (ст. 12): на территорию стран из перечня Роскомнадзора — свободно; в иные страны — при определённых условиях (согласие, договор, международные договоры); с 01.09.2025 ужесточение: уведомление/разрешение Роскомнадзора на трансграничную передачу (для стран вне перечня) с обязанностью оператора подтвердить соблюдение требований. *Норма меняется — проверяй актуальную редакцию.*
 - **Утечки** (ст. 21, ст. 23): обязанность уведомить Роскомнадзор (и, с 2023, в определённых случаях — о фактах утечек) и субъектов; оборотные штрафы за утечки (ст. 13.11 КоАП РФ с 2024–2025): для юрлиц до 3% выручки, но не менее 20 млн ₽ и не более 500 млн ₽ (за повторную утечку).
 - **Уничтожение ПДн** (ст. 21): по достижении целей, при отзыве согласия, по требованию субъекта.
 ## GDPR (ЕС)
 - **Сфера действия** (ст. 3): обработка в ЕС; или предложение товаров/услуг субъектам в ЕС; или мониторинг поведения субъектов в ЕС. → Для продуктов, работающих с пользователями из ЕС, GDPR применим независимо от места нахождения компании.
 - **Роли**: контролёр (определяет цели/средства), обработчик (по поручению). SaaS-провайдеры обычно обработчики; требуются **DPA** (Data Processing Agreement).
 - **Правовые основания** (ст. 6): согласие, договор, правовое обязательство, жизненно важные интересы, публичный интерес, **законный интерес** (legitimate interest — требует балансового теста LIA).
 - **Согласие** (ст. 7): свободное, конкретное, информированное, однозначное; отзыв так же прост, как предоставление; для детей — согласие родителей (ст. 8).
 - **Права субъектов** (ст. 15–22): доступ, исправление, удаление (right to be forgotten), ограничение, переносимость (portability), возражение, отказ от автоматизированных решений (profiling).
 - **Обязанности**: записи обработки (ст. 30), уведомление об утечках в течение 72 часов (ст. 33), уведомление субъектов (ст. 34), **DPIA** — оценка влияния на защиту данных для высокорисковых обработок (ст. 35), **DPO** — ответственный за защиту данных для определённых операторов (ст. 37), privacy by design/by default (ст. 25).
 - **Трансграничная передача** (ст. 44–49): решения об адекватности (adequacy), SCC (стандартные договорные оговорки), BCR, исключения.
 - **Штрафы** (ст. 83): до 20 млн евро или 4% мирового оборота (большее из двух) за тяжкие нарушения; до 10 млн евро / 2% — за остальные.
 ## Применение к продуктам и сервисам
 - **Cookies и трекинг**: согласие на необязательные cookies (ePrivacy / Директива 2009/136; в РФ — требования к cookie-баннерам формируются практикой Роскомнадзора и законом о «cookie» в стадии регулирования — уточнять актуальное).
 - **Аналитика** (Google Analytics, Яндекс.Метрика): обработка ПДн; нужны основания и (для ЕС) проверка легальности передачи (решения судов ЕС по Schrems II — SCC + доп. меры).
 - **Мобильные приложения**: политика конфиденциальности, разрешения, согласия, возрастные ограничения (COPPA в США, GDPR ст. 8, 152-ФЗ + закон о защите детей от вредной информации).
 - **SaaS/B2B**: DPA с клиентами, журналирование, локализация данных, порядок исполнения запросов субъектов.
 - **Локализация баз данных (РФ)**: операторы обязаны записывать/систематизировать ПДн граждан РФ в базах на территории РФ (ст. 18 ч. 5 152-ФЗ) — при сборе через интернет.
 ## Чек-лист для продукта
 1. Какие ПДн собираются и зачем (цели)?
 2. Есть ли правовое основание (согласие/договор/законный интерес)?
 3. Составлена ли политика конфиденциальности и получено ли согласие (форма)?
 4. Уведомлён ли Роскомнадзор (если требуется)?
 5. Соблюдена ли локализация баз данных (РФ)?
 6. Что происходит при запросе субъекта (доступ/удаление)?
 7. Урегулирована ли передача данных за границу (ЕС — SCC/adequacy; РФ — перечень РКН)?
 8. Есть ли DPA с подрядчиками/хостингом?
 9. Как реагируем на утечки (72 часа GDPR, уведомление РКН)?
@@ -115,6 +115,47 @@ service EveningDetectiveServer {
    };
  }
  rpc DeleteAccount(DeleteAccountReq) returns (DeleteAccountRsp) {
    option (google.api.http) = {
      delete: "/api/auth/delete-account"
    };
    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
      tags       : "Регистрация и вход";
      summary    : "Удалить учётную запись и персональные данные";
      description: "Удаляет учётную запись и персональные данные текущего пользователя (ст. 21 152-ФЗ). Требует заголовок X-Password с паролем учётной записи (подтверждение владельца; пароль не передаётся в URL).";
    };
  }
  rpc GetTerms(GetTermsReq) returns (GetTermsRsp) {
    option (google.api.http) = {
      get: "/api/terms"
    };
    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
      tags   : "Документы";
      summary: "Получить текст Пользовательского соглашения (оферты)";
    };
  }
  rpc GetPrivacy(GetPrivacyReq) returns (GetPrivacyRsp) {
    option (google.api.http) = {
      get: "/api/privacy"
    };
    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
      tags   : "Документы";
      summary: "Получить текст Политики конфиденциальности";
    };
  }
  rpc GetConsent(GetConsentReq) returns (GetConsentRsp) {
    option (google.api.http) = {
      get: "/api/consent"
    };
    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
      tags   : "Документы";
      summary: "Получить текст Согласия на обработку персональных данных";
    };
  }
  rpc GetUsers(GetUsersReq) returns (GetUsersRsp) {
    option (google.api.http) = {
      get: "/api/users"
@@ -324,6 +365,27 @@ service EveningDetectiveServer {
    };
  }
  rpc DownloadScenarioArchive(DownloadScenarioArchiveReq) returns (google.api.HttpBody) {
    option (google.api.http) = {
      get: "/api/scenarios/{id}/archive"
    };
    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
      tags   : "Сценарии";
      summary: "Скачать сценарий архивом (со всеми материалами и картинками)";
    };
  }
  rpc UploadScenarioArchive(google.api.HttpBody) returns (UploadScenarioArchiveRsp) {
    option (google.api.http) = {
      post: "/api/scenarios/archive"
      body: "*"
    };
    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
      tags   : "Сценарии";
      summary: "Создать сценарий из архива";
    };
  }
  rpc AddGame(AddGameReq) returns (AddGameRsp) {
    option (google.api.http) = {
      post: "/api/games"
@@ -366,6 +428,61 @@ service EveningDetectiveServer {
    };
  }
  rpc StartGame(StartGameReq) returns (StartGameRsp) {
    option (google.api.http) = {
      put : "/api/games/{id}/start"
      body: "*"
    };
    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
      tags   : "Игры";
      summary: "Начать игру";
    };
  }
  rpc PauseGame(PauseGameReq) returns (PauseGameRsp) {
    option (google.api.http) = {
      put : "/api/games/{id}/pause"
      body: "*"
    };
    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
      tags   : "Игры";
      summary: "Остановить игру";
    };
  }
  rpc PlayGame(PlayGameReq) returns (PlayGameRsp) {
    option (google.api.http) = {
      put : "/api/games/{id}/play"
      body: "*"
    };
    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
      tags   : "Игры";
      summary: "Продолжить игру";
    };
  }
  rpc FinishGame(FinishGameReq) returns (FinishGameRsp) {
    option (google.api.http) = {
      put : "/api/games/{id}/finish"
      body: "*"
    };
    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
      tags   : "Игры";
      summary: "Закончить игру";
    };
  }
  rpc ResetGame(ResetGameReq) returns (ResetGameRsp) {
    option (google.api.http) = {
      put : "/api/games/{id}/reset"
      body: "*"
    };
    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
      tags   : "Игры";
      summary: "Сбросить игру";
    };
  }
  rpc DeleteGame(DeleteGameReq) returns (DeleteGameRsp) {
    option (google.api.http) = {
      delete: "/api/games/{id}"
@@ -419,9 +536,9 @@ service EveningDetectiveServer {
    };
  }
-  rpc GetTeamActions(GetTeamActionsReq) returns (GetTeamActionsRsp) {
+  rpc GetTeamStory(GetTeamStoryReq) returns (GetTeamStoryRsp) {
    option (google.api.http) = {
-      get: "/api/teams/{id}/actions"
+      get: "/api/teams/{id}/story"
    };
    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
      security: {
@@ -445,6 +562,16 @@ service EveningDetectiveServer {
      summary: "Сделать ход";
    };
  }
  rpc DeleteLastTeamAction(DeleteLastTeamActionReq) returns (DeleteLastTeamActionRsp) {
    option (google.api.http) = {
      delete: "/api/teams/{id}/last-actions"
    };
    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
      tags   : "Ходы";
      summary: "Удалить последний ход";
    };
  }
 }
 message PingReq {}
@@ -462,6 +589,8 @@ message EchoRsp {
 message SignupReq {
  string username       = 1;
  string email          = 2;
  bool   accept_terms   = 3;
  bool   accept_privacy = 4;
 }
 message SignupRsp {
@@ -497,6 +626,39 @@ message RefreshRsp {
  string refreshToken = 3;
 }
 // Пароль подтверждает, что удаляет аккаунт его владелец, а не обладатель
 // украденного access-токена (ст. 21 152-ФЗ). Передаётся HTTP-заголовком
 // X-Password (пробрасывается матчером в cmd/evening_detective_server/main.go),
 // чтобы креденшел не попадал в URL/query-параметры и логи.
 message DeleteAccountReq {}
 message DeleteAccountRsp {
  string error = 1;
 }
 // Документы раздаются по постоянным URL, на которые ссылается сервис при
 // фиксации акцептов соглашений (user_agreements) и форма регистрации.
 message GetTermsReq {}
 message GetTermsRsp {
  string error = 1;
  string text  = 2;
 }
 message GetPrivacyReq {}
 message GetPrivacyRsp {
  string error = 1;
  string text  = 2;
 }
 message GetConsentReq {}
 message GetConsentRsp {
  string error = 1;
  string text  = 2;
 }
 message GetUsersReq {}
 message GetUsersRsp {
@@ -706,6 +868,15 @@ message DeleteScenarioPlaceRsp {
  string error = 1;
 }
 message DownloadScenarioArchiveReq {
  int32 id = 1;
 }
 message UploadScenarioArchiveRsp {
  string error = 1;
  int32  id    = 2;
 }
 message AddGameReq {
  string                    name        = 1;
  string                    description = 2;
@@ -733,11 +904,17 @@ message Game {
  string                             status      = 5;
  Scenario                           scenario    = 6;
  repeated Team                      teams       = 7;
  optional google.protobuf.Timestamp started_at  = 8;
  optional google.protobuf.Timestamp ended_at    = 9;
 }
 message Team {
  int32                id            = 1;
  string               name          = 2;
  string               status        = 3;
  string               password      = 4;
  int32                actions_count = 5;
  repeated Application applications  = 6;
 }
 message GetGameReq {
@@ -761,6 +938,46 @@ message UpdateGameRsp {
  string error = 1;
 }
 message StartGameReq {
  int32 id = 1;
 }
 message StartGameRsp {
  string error = 1;
 }
 message PauseGameReq {
  int32 id = 1;
 }
 message PauseGameRsp {
  string error = 1;
 }
 message PlayGameReq {
  int32 id = 1;
 }
 message PlayGameRsp {
  string error = 1;
 }
 message FinishGameReq {
  int32 id = 1;
 }
 message FinishGameRsp {
  string error = 1;
 }
 message ResetGameReq {
  int32 id = 1;
 }
 message ResetGameRsp {
  string error = 1;
 }
 message DeleteGameReq {
  int32 id = 1;
 }
@@ -776,6 +993,8 @@ message AddTeamReq {
 message AddTeamRsp {
  string error    = 1;
  int32  id       = 2;
  string password = 3;
 }
 message UpdateTeamReq {
@@ -804,14 +1023,15 @@ message GiveTeamApplicationsRsp {
  string error = 1;
 }
-message GetTeamActionsReq {
+message GetTeamStoryReq {
  int64  id       = 1;
  string password = 2;
 }
-message GetTeamActionsRsp {
+message GetTeamStoryRsp {
  string error = 1;
-  repeated Place places = 2;
+  Story  story = 2;
  Game   game  = 3;
 }
 message AddTeamActionReq {
@@ -823,3 +1043,11 @@ message AddTeamActionReq {
 message AddTeamActionRsp {
  string error = 1;
 }
 message DeleteLastTeamActionReq {
  int64 id = 1;
 }
 message DeleteLastTeamActionRsp {
  string error = 1;
 }
@@ -0,0 +1,183 @@
 package main
 import (
 	"bytes"
 	"context"
 	"io"
 	"net"
 	"net/http"
 	"net/http/httptest"
 	"strings"
 	"sync"
 	"testing"
 	"evening_detective_server/internal/modules/scenario_archive"
 	proto "evening_detective_server/proto"
 	"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
 	"google.golang.org/genproto/googleapis/api/httpbody"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials/insecure"
 	"google.golang.org/grpc/metadata"
 )
 // archiveStub — минимальный gRPC-сервер, реализующий только архивные RPC.
 type archiveStub struct {
 	proto.UnimplementedEveningDetectiveServerServer
 	mu       sync.Mutex
 	uploaded []byte
 }
 func (s *archiveStub) UploadScenarioArchive(_ context.Context, req *httpbody.HttpBody) (*proto.UploadScenarioArchiveRsp, error) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	s.uploaded = append([]byte(nil), req.Data...)
 	return &proto.UploadScenarioArchiveRsp{Id: 42}, nil
 }
 func (s *archiveStub) DownloadScenarioArchive(ctx context.Context, _ *proto.DownloadScenarioArchiveReq) (*httpbody.HttpBody, error) {
 	_ = grpc.SetHeader(ctx, metadata.Pairs("Content-Disposition", `attachment; filename="test.zip"`))
 	return &httpbody.HttpBody{
 		Data:        []byte("zip-data"),
 		ContentType: "application/zip",
 	}, nil
 }
 func (s *archiveStub) getUploaded() []byte {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	return append([]byte(nil), s.uploaded...)
 }
 // newTestGateway поднимает gRPC-сервер со stub и grpc-gateway с теми же
 // опциями, что и в main.go (outgoing matcher + rawBodyMarshaler).
 func newTestGateway(t *testing.T, stub proto.EveningDetectiveServerServer) *httptest.Server {
 	t.Helper()
 	lis, err := net.Listen("tcp", "127.0.0.1:0")
 	if err != nil {
 		t.Fatalf("listen: %v", err)
 	}
 	gs := grpc.NewServer()
 	proto.RegisterEveningDetectiveServerServer(gs, stub)
 	go func() { _ = gs.Serve(lis) }()
 	t.Cleanup(gs.Stop)
 	conn, err := grpc.NewClient(lis.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials()))
 	if err != nil {
 		t.Fatalf("dial: %v", err)
 	}
 	t.Cleanup(func() { _ = conn.Close() })
 	mux := runtime.NewServeMux(
 		runtime.WithOutgoingHeaderMatcher(func(key string) (string, bool) {
 			if strings.EqualFold(key, "Content-Disposition") {
 				return "Content-Disposition", true
 			}
 			return runtime.DefaultHeaderMatcher(key)
 		}),
 		runtime.WithMarshalerOption("application/zip", &rawBodyMarshaler{
 			Marshaler: &runtime.HTTPBodyMarshaler{Marshaler: &runtime.JSONPb{}},
 		}),
 	)
 	if err := proto.RegisterEveningDetectiveServerHandler(context.Background(), mux, conn); err != nil {
 		t.Fatalf("register gateway: %v", err)
 	}
 	ts := httptest.NewServer(mux)
 	t.Cleanup(ts.Close)
 	return ts
 }
 func TestGatewayUploadRawZip(t *testing.T) {
 	stub := &archiveStub{}
 	ts := newTestGateway(t, stub)
 	raw := []byte("PK\x03\x04raw-zip-bytes")
 	resp, err := http.Post(ts.URL+"/api/scenarios/archive", "application/zip", bytes.NewReader(raw))
 	if err != nil {
 		t.Fatalf("POST: %v", err)
 	}
 	defer resp.Body.Close()
 	body, _ := io.ReadAll(resp.Body)
 	if resp.StatusCode != http.StatusOK {
 		t.Fatalf("status = %d, body = %s", resp.StatusCode, body)
 	}
 	if !strings.Contains(string(body), `"id":42`) {
 		t.Errorf("ответ = %s, want id 42", body)
 	}
 	if got := stub.getUploaded(); !bytes.Equal(got, raw) {
 		t.Errorf("сервер получил %q, want %q", got, raw)
 	}
 }
 func TestGatewayDownloadZipWithContentDisposition(t *testing.T) {
 	stub := &archiveStub{}
 	ts := newTestGateway(t, stub)
 	resp, err := http.Get(ts.URL + "/api/scenarios/1/archive")
 	if err != nil {
 		t.Fatalf("GET: %v", err)
 	}
 	defer resp.Body.Close()
 	body, _ := io.ReadAll(resp.Body)
 	if resp.StatusCode != http.StatusOK {
 		t.Fatalf("status = %d", resp.StatusCode)
 	}
 	if ct := resp.Header.Get("Content-Type"); ct != "application/zip" {
 		t.Errorf("Content-Type = %q, want application/zip", ct)
 	}
 	if cd := resp.Header.Get("Content-Disposition"); cd != `attachment; filename="test.zip"` {
 		t.Errorf("Content-Disposition = %q", cd)
 	}
 	if string(body) != "zip-data" {
 		t.Errorf("body = %q, want zip-data", body)
 	}
 }
 // TestCORSExposesContentDisposition — фронт через fetch должен читать
 // Content-Disposition (имя файла архива) из ответа.
 func TestCORSExposesContentDisposition(t *testing.T) {
 	h := cors(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
 		w.WriteHeader(http.StatusOK)
 	}))
 	rec := httptest.NewRecorder()
 	h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/api/scenarios/1/archive", nil))
 	if got := rec.Header().Get("Access-Control-Expose-Headers"); got != "Content-Disposition" {
 		t.Errorf("Access-Control-Expose-Headers = %q, want Content-Disposition", got)
 	}
 }
 // TestLimitArchiveUploadBody — тело загрузки архива ограничено на HTTP-слое
 // (защита от OOM), прочие маршруты не затронуты.
 func TestLimitArchiveUploadBody(t *testing.T) {
 	h := limitArchiveUploadBody(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		_, err := io.ReadAll(r.Body)
 		if err != nil {
 			w.WriteHeader(http.StatusRequestEntityTooLarge)
 			return
 		}
 		w.WriteHeader(http.StatusOK)
 	}))
 	t.Run("upload route rejected when over limit", func(t *testing.T) {
 		big := bytes.Repeat([]byte("x"), scenario_archive.MaxArchiveSize()+1)
 		req := httptest.NewRequest(http.MethodPost, "/api/scenarios/archive", bytes.NewReader(big))
 		rec := httptest.NewRecorder()
 		h.ServeHTTP(rec, req)
 		if rec.Code != http.StatusRequestEntityTooLarge {
 			t.Errorf("status = %d, want %d", rec.Code, http.StatusRequestEntityTooLarge)
 		}
 	})
 	t.Run("other routes not limited", func(t *testing.T) {
 		req := httptest.NewRequest(http.MethodPost, "/api/files/upload", bytes.NewReader([]byte("small")))
 		rec := httptest.NewRecorder()
 		h.ServeHTTP(rec, req)
 		if rec.Code != http.StatusOK {
 			t.Errorf("status = %d, want %d", rec.Code, http.StatusOK)
 		}
 	})
 }
@@ -4,10 +4,16 @@ import (
 	"context"
 	_ "embed"
 	"evening_detective_server/internal/app"
 	"evening_detective_server/internal/modules/cleaner"
 	"evening_detective_server/internal/modules/email_sender"
 	"evening_detective_server/internal/modules/file_storage"
 	"evening_detective_server/internal/modules/password_generator"
 	"evening_detective_server/internal/modules/processor_jwt"
 	"evening_detective_server/internal/modules/scenario_archive"
 	"evening_detective_server/internal/modules/storytelling"
 	"evening_detective_server/internal/modules/string_tools"
 	"evening_detective_server/internal/repos/actions_repo"
 	"evening_detective_server/internal/repos/applications_repo"
 	"evening_detective_server/internal/repos/games_repo"
 	"evening_detective_server/internal/repos/refresh_tokens_repo"
 	"evening_detective_server/internal/repos/scenarios_repo"
@@ -23,12 +29,15 @@ import (
 	"net"
 	"net/http"
 	"os"
 	"strings"
 	"time"
 	"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
 	"github.com/jackc/pgx/v5/pgxpool"
 	"github.com/joho/godotenv"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials/insecure"
 	"google.golang.org/protobuf/encoding/protojson"
 	"github.com/swaggest/swgui/v5emb"
 )
@@ -53,16 +62,25 @@ func main() {
 	}
 	usersRepo := users_repo.NewUserRepo(dbpool)
-	passwordGenerator := password_generator.NewGenerator(8)
+	passwordGenerator := password_generator.NewGenerator(12)
 	smtpTimeout := 10 * time.Second
 	if v := os.Getenv("SMTP_TIMEOUT"); v != "" {
 		if d, err := time.ParseDuration(v); err == nil && d > 0 {
 			smtpTimeout = d
 		}
 	}
 	emailSender := email_sender.NewSender(
 		os.Getenv("SMTP_HOST"),
 		os.Getenv("SMTP_PORT"),
 		os.Getenv("SMTP_USER"),
 		os.Getenv("SMTP_PASSWORD"),
 		os.Getenv("SMTP_FROM_NAME"),
 		os.Getenv("SMTP_REPLY_TO"),
 		smtpTimeout,
 	)
 	processorJWT := processor_jwt.NewProcessor(os.Getenv("JWT_SECRET"))
 	refreshTokensRepo := refresh_tokens_repo.NewRefreshTokensRepo(dbpool)
-	usersService := users_service.NewUsersService(usersRepo, passwordGenerator, emailSender, processorJWT, refreshTokensRepo)
+	usersService := users_service.NewUsersService(usersRepo, passwordGenerator, emailSender, processorJWT, refreshTokensRepo, os.Getenv("APP_BASE_URL"))
 	uiService := ui_service.NewUiService()
 	fileStorage, err := file_storage.NewRustFSStorage(
 		os.Getenv("S3_HOST"),
@@ -73,19 +91,32 @@ func main() {
 	if err != nil {
 		log.Fatalf("Unable to create connection rustfs: %v\n", err)
 	}
-	fileService := file_service.NewFileService(fileStorage)
+	fileService := file_service.NewFileService(fileStorage, string_tools.NewStringTools())
 	scenariosRepo := scenarios_repo.NewScenariosRepo(dbpool)
 	cleaner := cleaner.NewCleaner()
 	scenarioService := scenarios_service.NewScenarioService(
 		scenariosRepo,
 		cleaner,
 		os.Getenv("FILE_PREFIX_DOMAIN"),
 		fileStorage,
 		scenario_archive.NewScenarioArchive(),
 	)
 	gameRepo := games_repo.NewGamesRepo(dbpool)
 	teamRepo := teams_repo.NewTeamsRepo(dbpool)
 	storyteller := storytelling.NewStory(cleaner)
 	actionsRepo := actions_repo.NewActionsRepo(dbpool)
 	applicationsRepo := applications_repo.NewApplicationsRepo(dbpool)
 	gameService := game_service.NewGameService(
 		gameRepo,
 		teamRepo,
 		scenariosRepo,
 		scenarioService,
 		os.Getenv("FILE_PREFIX_DOMAIN"),
 		passwordGenerator,
 		storyteller,
 		actionsRepo,
 		applicationsRepo,
 		cleaner,
 	)
 	// Create a listener on TCP port
@@ -108,8 +139,11 @@ func main() {
 					"/crabs.evening_detective_server.EveningDetectiveServer/DownloadFile":        true,
 					"/crabs.evening_detective_server.EveningDetectiveServer/GetScenario":         true,
 					"/crabs.evening_detective_server.EveningDetectiveServer/GetScenariosCatalog": true,
-					"/crabs.evening_detective_server.EveningDetectiveServer/GetTeamActions":      true,
+					"/crabs.evening_detective_server.EveningDetectiveServer/GetTeamStory":        true,
 					"/crabs.evening_detective_server.EveningDetectiveServer/AddTeamAction":       true,
 					"/crabs.evening_detective_server.EveningDetectiveServer/GetTerms":            true,
 					"/crabs.evening_detective_server.EveningDetectiveServer/GetPrivacy":          true,
 					"/crabs.evening_detective_server.EveningDetectiveServer/GetConsent":          true,
 				},
 				processorJWT,
 			),
@@ -143,7 +177,42 @@ func main() {
 		log.Fatalln("Failed to dial server:", err)
 	}
-	gwmux := runtime.NewServeMux()
+	// X-Real-IP пробрасывается от доверенного обратного прокси (если фронт-
 	// контур развёрнут перед gateway, см. docs/COMPLIANCE.md п. 6.6) и
 	// используется в clientInfoFromContext для фиксации IP клиента при
 	// акцепте соглашений (ст. 9 152-ФЗ). X-Password — подтверждение паролем
 	// при удалении аккаунта (не в query, чтобы не светить креденшел в URL
 	// и логах).
 	// Сырая загрузка архива (без base64) для распространённых Content-Type;
 	// JSON-вариант {"data": "<base64>"} работает через application/json.
 	rawBody := &rawBodyMarshaler{
 		Marshaler: &runtime.HTTPBodyMarshaler{
 			Marshaler: &runtime.JSONPb{
 				UnmarshalOptions: protojson.UnmarshalOptions{DiscardUnknown: true},
 			},
 		},
 	}
 	gwmux := runtime.NewServeMux(
 		runtime.WithIncomingHeaderMatcher(func(key string) (string, bool) {
 			switch {
 			case strings.EqualFold(key, "X-Real-IP"):
 				return "x-real-ip", true
 			case strings.EqualFold(key, "X-Password"):
 				return "x-password", true
 			}
 			return runtime.DefaultHeaderMatcher(key)
 		}),
 		// Проброс Content-Disposition от сервиса в HTTP-ответ.
 		runtime.WithOutgoingHeaderMatcher(func(key string) (string, bool) {
 			if strings.EqualFold(key, "Content-Disposition") {
 				return "Content-Disposition", true
 			}
 			return runtime.DefaultHeaderMatcher(key)
 		}),
 		runtime.WithMarshalerOption("application/zip", rawBody),
 		runtime.WithMarshalerOption("application/octet-stream", rawBody),
 		runtime.WithMarshalerOption("application/x-zip-compressed", rawBody),
 	)
 	// Register Greeter
 	err = proto.RegisterEveningDetectiveServerHandler(context.Background(), gwmux, conn)
 	if err != nil {
@@ -158,7 +227,9 @@ func main() {
 		w.Header().Set("Content-Type", "application/json")
 		w.Write(swaggerJSON)
 	})
-	mainMux.Handle("/api/", gwmux)
+	// MaxBytesReader на HTTP-слое: gateway буферизует тело целиком, без лимита
 	// проверки в хендлере не спасут от OOM.
 	mainMux.Handle("/api/", limitArchiveUploadBody(gwmux))
 	gwServer := &http.Server{
 		Addr:    ":8090",
@@ -175,9 +246,22 @@ func cors(h http.Handler) http.Handler {
 		w.Header().Set("Access-Control-Allow-Origin", "*")
 		w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE")
 		w.Header().Set("Access-Control-Allow-Headers", "Accept, Content-Type, Content-Length, Accept-Encoding, Authorization, ResponseType, X-Id, X-Password")
 		// Content-Disposition нужен фронту, чтобы прочитать имя файла архива.
 		w.Header().Set("Access-Control-Expose-Headers", "Content-Disposition")
 		if r.Method == "OPTIONS" {
 			return
 		}
 		h.ServeHTTP(w, r)
 	})
 }
 // limitArchiveUploadBody ограничивает тело запроса загрузки архива
 // (см. rawBodyDecoder: gateway читает тело в память целиком).
 func limitArchiveUploadBody(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		if r.Method == http.MethodPost && r.URL.Path == "/api/scenarios/archive" {
 			r.Body = http.MaxBytesReader(w, r.Body, int64(scenario_archive.MaxArchiveSize()))
 		}
 		next.ServeHTTP(w, r)
 	})
 }
@@ -16,6 +16,30 @@
    "application/json"
  ],
  "paths": {
    "/api/auth/delete-account": {
      "delete": {
        "summary": "Удалить учётную запись и персональные данные",
        "description": "Удаляет учётную запись и персональные данные текущего пользователя (ст. 21 152-ФЗ). Требует заголовок X-Password с паролем учётной записи (подтверждение владельца; пароль не передаётся в URL).",
        "operationId": "EveningDetectiveServer_DeleteAccount",
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/evening_detective_serverDeleteAccountRsp"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/rpcStatus"
            }
          }
        },
        "tags": [
          "Регистрация и вход"
        ]
      }
    },
    "/api/auth/login": {
      "post": {
        "summary": "Войти и получить токена доступа",
@@ -191,6 +215,29 @@
        ]
      }
    },
    "/api/consent": {
      "get": {
        "summary": "Получить текст Согласия на обработку персональных данных",
        "operationId": "EveningDetectiveServer_GetConsent",
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/evening_detective_serverGetConsentRsp"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/rpcStatus"
            }
          }
        },
        "tags": [
          "Документы"
        ]
      }
    },
    "/api/files/upload": {
      "post": {
        "summary": "Загрузить файл",
@@ -409,6 +456,206 @@
        ]
      }
    },
    "/api/games/{id}/finish": {
      "put": {
        "summary": "Закончить игру",
        "operationId": "EveningDetectiveServer_FinishGame",
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/evening_detective_serverFinishGameRsp"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/rpcStatus"
            }
          }
        },
        "parameters": [
          {
            "name": "id",
            "in": "path",
            "required": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/EveningDetectiveServerFinishGameBody"
            }
          }
        ],
        "tags": [
          "Игры"
        ]
      }
    },
    "/api/games/{id}/pause": {
      "put": {
        "summary": "Остановить игру",
        "operationId": "EveningDetectiveServer_PauseGame",
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/evening_detective_serverPauseGameRsp"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/rpcStatus"
            }
          }
        },
        "parameters": [
          {
            "name": "id",
            "in": "path",
            "required": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/EveningDetectiveServerPauseGameBody"
            }
          }
        ],
        "tags": [
          "Игры"
        ]
      }
    },
    "/api/games/{id}/play": {
      "put": {
        "summary": "Продолжить игру",
        "operationId": "EveningDetectiveServer_PlayGame",
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/evening_detective_serverPlayGameRsp"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/rpcStatus"
            }
          }
        },
        "parameters": [
          {
            "name": "id",
            "in": "path",
            "required": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/EveningDetectiveServerPlayGameBody"
            }
          }
        ],
        "tags": [
          "Игры"
        ]
      }
    },
    "/api/games/{id}/reset": {
      "put": {
        "summary": "Сбросить игру",
        "operationId": "EveningDetectiveServer_ResetGame",
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/evening_detective_serverResetGameRsp"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/rpcStatus"
            }
          }
        },
        "parameters": [
          {
            "name": "id",
            "in": "path",
            "required": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/EveningDetectiveServerResetGameBody"
            }
          }
        ],
        "tags": [
          "Игры"
        ]
      }
    },
    "/api/games/{id}/start": {
      "put": {
        "summary": "Начать игру",
        "operationId": "EveningDetectiveServer_StartGame",
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/evening_detective_serverStartGameRsp"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/rpcStatus"
            }
          }
        },
        "parameters": [
          {
            "name": "id",
            "in": "path",
            "required": true,
            "type": "integer",
            "format": "int32"
          },
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/EveningDetectiveServerStartGameBody"
            }
          }
        ],
        "tags": [
          "Игры"
        ]
      }
    },
    "/api/my-scenarios": {
      "get": {
        "summary": "Получить свои сценарии",
@@ -432,6 +679,29 @@
        ]
      }
    },
    "/api/privacy": {
      "get": {
        "summary": "Получить текст Политики конфиденциальности",
        "operationId": "EveningDetectiveServer_GetPrivacy",
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/evening_detective_serverGetPrivacyRsp"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/rpcStatus"
            }
          }
        },
        "tags": [
          "Документы"
        ]
      }
    },
    "/api/scenario": {
      "post": {
        "summary": "Создать сценарий",
@@ -465,6 +735,40 @@
        ]
      }
    },
    "/api/scenarios/archive": {
      "post": {
        "summary": "Создать сценарий из архива",
        "operationId": "EveningDetectiveServer_UploadScenarioArchive",
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/evening_detective_serverUploadScenarioArchiveRsp"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/rpcStatus"
            }
          }
        },
        "parameters": [
          {
            "name": "body",
            "description": "Message that represents an arbitrary HTTP body. It should only be used for\npayload formats that can't be represented as JSON, such as raw binary or\nan HTML page.\n\n\nThis message can be used both in streaming and non-streaming API methods in\nthe request as well as the response.\n\nIt can be used as a top-level request field, which is convenient if one\nwants to extract parameters from either the URL or HTTP template into the\nrequest fields and also want access to the raw HTTP body.\n\nExample:\n\n    message GetResourceRequest {\n      // A unique request id.\n      string request_id = 1;\n\n      // The raw HTTP body is bound to this field.\n      google.api.HttpBody http_body = 2;\n\n    }\n\n    service ResourceService {\n      rpc GetResource(GetResourceRequest)\n        returns (google.api.HttpBody);\n      rpc UpdateResource(google.api.HttpBody)\n        returns (google.protobuf.Empty);\n\n    }\n\nExample with streaming methods:\n\n    service CaldavService {\n      rpc GetCalendar(stream google.api.HttpBody)\n        returns (stream google.api.HttpBody);\n      rpc UpdateCalendar(stream google.api.HttpBody)\n        returns (stream google.api.HttpBody);\n\n    }\n\nUse of this type only changes how the request and response bodies are\nhandled, all other features will continue to work unchanged.",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/apiHttpBody"
            }
          }
        ],
        "tags": [
          "Сценарии"
        ]
      }
    },
    "/api/scenarios/{id}": {
      "get": {
        "summary": "Получить сценарий по id",
@@ -565,6 +869,38 @@
        ]
      }
    },
    "/api/scenarios/{id}/archive": {
      "get": {
        "summary": "Скачать сценарий архивом (со всеми материалами и картинками)",
        "operationId": "EveningDetectiveServer_DownloadScenarioArchive",
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/apiHttpBody"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/rpcStatus"
            }
          }
        },
        "parameters": [
          {
            "name": "id",
            "in": "path",
            "required": true,
            "type": "integer",
            "format": "int32"
          }
        ],
        "tags": [
          "Сценарии"
        ]
      }
    },
    "/api/scenarios/{id}/draft": {
      "put": {
        "summary": "Снять с публикации сценарий",
@@ -903,47 +1239,6 @@
      }
    },
    "/api/teams/{id}/actions": {
      "get": {
        "summary": "Получить ходы",
        "operationId": "EveningDetectiveServer_GetTeamActions",
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/evening_detective_serverGetTeamActionsRsp"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/rpcStatus"
            }
          }
        },
        "parameters": [
          {
            "name": "id",
            "in": "path",
            "required": true,
            "type": "string",
            "format": "int64"
          },
          {
            "name": "password",
            "in": "query",
            "required": false,
            "type": "string"
          }
        ],
        "tags": [
          "Ходы"
        ],
        "security": [
          {
            "": []
          }
        ]
      },
      "post": {
        "summary": "Сделать ход",
        "operationId": "EveningDetectiveServer_AddTeamAction",
@@ -1028,6 +1323,104 @@
        ]
      }
    },
    "/api/teams/{id}/last-actions": {
      "delete": {
        "summary": "Удалить последний ход",
        "operationId": "EveningDetectiveServer_DeleteLastTeamAction",
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/evening_detective_serverDeleteLastTeamActionRsp"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/rpcStatus"
            }
          }
        },
        "parameters": [
          {
            "name": "id",
            "in": "path",
            "required": true,
            "type": "string",
            "format": "int64"
          }
        ],
        "tags": [
          "Ходы"
        ]
      }
    },
    "/api/teams/{id}/story": {
      "get": {
        "summary": "Получить ходы",
        "operationId": "EveningDetectiveServer_GetTeamStory",
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/evening_detective_serverGetTeamStoryRsp"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/rpcStatus"
            }
          }
        },
        "parameters": [
          {
            "name": "id",
            "in": "path",
            "required": true,
            "type": "string",
            "format": "int64"
          },
          {
            "name": "password",
            "in": "query",
            "required": false,
            "type": "string"
          }
        ],
        "tags": [
          "Ходы"
        ],
        "security": [
          {
            "": []
          }
        ]
      }
    },
    "/api/terms": {
      "get": {
        "summary": "Получить текст Пользовательского соглашения (оферты)",
        "operationId": "EveningDetectiveServer_GetTerms",
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/evening_detective_serverGetTermsRsp"
            }
          },
          "default": {
            "description": "An unexpected error response.",
            "schema": {
              "$ref": "#/definitions/rpcStatus"
            }
          }
        },
        "tags": [
          "Документы"
        ]
      }
    },
    "/api/test/echo": {
      "post": {
        "summary": "Проверить обработку данных",
@@ -1313,6 +1706,9 @@
    "EveningDetectiveServerDraftScenarioBody": {
      "type": "object"
    },
    "EveningDetectiveServerFinishGameBody": {
      "type": "object"
    },
    "EveningDetectiveServerGiveTeamApplicationsBody": {
      "type": "object",
      "properties": {
@@ -1321,9 +1717,21 @@
        }
      }
    },
    "EveningDetectiveServerPauseGameBody": {
      "type": "object"
    },
    "EveningDetectiveServerPlayGameBody": {
      "type": "object"
    },
    "EveningDetectiveServerPublicScenarioBody": {
      "type": "object"
    },
    "EveningDetectiveServerResetGameBody": {
      "type": "object"
    },
    "EveningDetectiveServerStartGameBody": {
      "type": "object"
    },
    "EveningDetectiveServerUpdateGameBody": {
      "type": "object",
      "properties": {
@@ -1480,6 +1888,13 @@
      "properties": {
        "error": {
          "type": "string"
        },
        "id": {
          "type": "integer",
          "format": "int32"
        },
        "password": {
          "type": "string"
        }
      }
    },
@@ -1502,6 +1917,14 @@
        }
      }
    },
    "evening_detective_serverDeleteAccountRsp": {
      "type": "object",
      "properties": {
        "error": {
          "type": "string"
        }
      }
    },
    "evening_detective_serverDeleteGameRsp": {
      "type": "object",
      "properties": {
@@ -1510,6 +1933,14 @@
        }
      }
    },
    "evening_detective_serverDeleteLastTeamActionRsp": {
      "type": "object",
      "properties": {
        "error": {
          "type": "string"
        }
      }
    },
    "evening_detective_serverDeleteScenarioPlaceRsp": {
      "type": "object",
      "properties": {
@@ -1576,6 +2007,14 @@
        }
      }
    },
    "evening_detective_serverFinishGameRsp": {
      "type": "object",
      "properties": {
        "error": {
          "type": "string"
        }
      }
    },
    "evening_detective_serverGame": {
      "type": "object",
      "properties": {
@@ -1605,6 +2044,25 @@
            "type": "object",
            "$ref": "#/definitions/evening_detective_serverTeam"
          }
        },
        "startedAt": {
          "type": "string",
          "format": "date-time"
        },
        "endedAt": {
          "type": "string",
          "format": "date-time"
        }
      }
    },
    "evening_detective_serverGetConsentRsp": {
      "type": "object",
      "properties": {
        "error": {
          "type": "string"
        },
        "text": {
          "type": "string"
        }
      }
    },
@@ -1674,6 +2132,17 @@
        }
      }
    },
    "evening_detective_serverGetPrivacyRsp": {
      "type": "object",
      "properties": {
        "error": {
          "type": "string"
        },
        "text": {
          "type": "string"
        }
      }
    },
    "evening_detective_serverGetScenarioRsp": {
      "type": "object",
      "properties": {
@@ -1700,19 +2169,29 @@
        }
      }
    },
-    "evening_detective_serverGetTeamActionsRsp": {
+    "evening_detective_serverGetTeamStoryRsp": {
      "type": "object",
      "properties": {
        "error": {
          "type": "string"
        },
-        "places": {
+        "story": {
-          "type": "array",
+          "$ref": "#/definitions/evening_detective_serverStory"
-          "items": {
+        },
-            "type": "object",
+        "game": {
-            "$ref": "#/definitions/evening_detective_serverPlace"
+          "$ref": "#/definitions/evening_detective_serverGame"
        }
      }
    },
    "evening_detective_serverGetTermsRsp": {
      "type": "object",
      "properties": {
        "error": {
          "type": "string"
        },
        "text": {
          "type": "string"
        }
      }
    },
    "evening_detective_serverGetUserByIdRsp": {
@@ -1782,6 +2261,14 @@
        }
      }
    },
    "evening_detective_serverPauseGameRsp": {
      "type": "object",
      "properties": {
        "error": {
          "type": "string"
        }
      }
    },
    "evening_detective_serverPingRsp": {
      "type": "object"
    },
@@ -1826,6 +2313,14 @@
        }
      }
    },
    "evening_detective_serverPlayGameRsp": {
      "type": "object",
      "properties": {
        "error": {
          "type": "string"
        }
      }
    },
    "evening_detective_serverPublicScenarioRsp": {
      "type": "object",
      "properties": {
@@ -1872,6 +2367,14 @@
        }
      }
    },
    "evening_detective_serverResetGameRsp": {
      "type": "object",
      "properties": {
        "error": {
          "type": "string"
        }
      }
    },
    "evening_detective_serverScenario": {
      "type": "object",
      "properties": {
@@ -1919,6 +2422,12 @@
        },
        "email": {
          "type": "string"
        },
        "acceptTerms": {
          "type": "boolean"
        },
        "acceptPrivacy": {
          "type": "boolean"
        }
      }
    },
@@ -1930,6 +2439,14 @@
        }
      }
    },
    "evening_detective_serverStartGameRsp": {
      "type": "object",
      "properties": {
        "error": {
          "type": "string"
        }
      }
    },
    "evening_detective_serverStory": {
      "type": "object",
      "properties": {
@@ -1951,6 +2468,23 @@
        },
        "name": {
          "type": "string"
        },
        "status": {
          "type": "string"
        },
        "password": {
          "type": "string"
        },
        "actionsCount": {
          "type": "integer",
          "format": "int32"
        },
        "applications": {
          "type": "array",
          "items": {
            "type": "object",
            "$ref": "#/definitions/evening_detective_serverApplication"
          }
        }
      }
    },
@@ -2009,6 +2543,18 @@
        }
      }
    },
    "evening_detective_serverUploadScenarioArchiveRsp": {
      "type": "object",
      "properties": {
        "error": {
          "type": "string"
        },
        "id": {
          "type": "integer",
          "format": "int32"
        }
      }
    },
    "evening_detective_serverUser": {
      "type": "object",
      "properties": {
@@ -0,0 +1,41 @@
 package main
 import (
 	"io"
 	"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
 	"google.golang.org/genproto/googleapis/api/httpbody"
 )
 // rawBodyMarshaler — маршалер для бинарного тела (application/zip и др.):
 // запрос попадает в HttpBody.Data без base64-JSON, для остального делегирует
 // JSON-маршалеру (работает и {"data": "<base64>"}).
 type rawBodyMarshaler struct {
 	runtime.Marshaler
 }
 func (m *rawBodyMarshaler) NewDecoder(r io.Reader) runtime.Decoder {
 	return rawBodyDecoder{
 		Decoder: m.Marshaler.NewDecoder(r),
 		r:       r,
 	}
 }
 // rawBodyDecoder — Decoder: для *httpbody.HttpBody читает тело целиком в Data,
 // для protobuf-сообщений декодирует JSON как обычно.
 type rawBodyDecoder struct {
 	runtime.Decoder
 	r io.Reader
 }
 func (d rawBodyDecoder) Decode(v interface{}) error {
 	if body, ok := v.(*httpbody.HttpBody); ok {
 		data, err := io.ReadAll(d.r)
 		if err != nil {
 			return err
 		}
 		body.Data = data
 		return nil
 	}
 	return d.Decoder.Decode(v)
 }
@@ -0,0 +1,46 @@
 package main
 import (
 	"bytes"
 	"strings"
 	"testing"
 	proto "evening_detective_server/proto"
 	"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
 	"google.golang.org/genproto/googleapis/api/httpbody"
 )
 func newTestRawBodyMarshaler() *rawBodyMarshaler {
 	return &rawBodyMarshaler{
 		Marshaler: &runtime.HTTPBodyMarshaler{
 			Marshaler: &runtime.JSONPb{},
 		},
 	}
 }
 func TestRawBodyDecoderDecodesHttpBody(t *testing.T) {
 	m := newTestRawBodyMarshaler()
 	raw := []byte("PK\x03\x04fake-zip-bytes")
 	protoReq := &httpbody.HttpBody{}
 	if err := m.NewDecoder(bytes.NewReader(raw)).Decode(protoReq); err != nil {
 		t.Fatalf("Decode: %v", err)
 	}
 	if !bytes.Equal(protoReq.Data, raw) {
 		t.Errorf("Data = %q, want %q", protoReq.Data, raw)
 	}
 }
 func TestRawBodyMarshalerDelegatesToJSONForProtos(t *testing.T) {
 	m := newTestRawBodyMarshaler()
 	// Для protobuf-сообщения (не HttpBody) декодирование идёт через JSON.
 	req := &proto.EchoReq{}
 	if err := m.NewDecoder(strings.NewReader(`{"text":"hi"}`)).Decode(req); err != nil {
 		t.Fatalf("Decode: %v", err)
 	}
 	if req.Text != "hi" {
 		t.Errorf("Text = %q, want hi", req.Text)
 	}
 }
@@ -0,0 +1,123 @@
 # ЧЕК-ЛИСТ COMPLIANCE: ПРИВЕДЕНИЕ СЕРВИСА В СООТВЕТСТВИЕ С ДОКУМЕНТАМИ
 Сервис «Вечерний детектив» · Обновлено: 18.08.2026
 Сопутствующие документы: `docs/TERMS.md` (Пользовательское соглашение), `docs/PRIVACY.md` (Политика конфиденциальности), `docs/CONSENT.md` (Согласие на обработку ПДн).
 Легенда: ✅ — реализовано, 🟡 — частично / требует решения владельца, ⬜ — осталось сделать.
 ---
 ## 1. Юридические документы
 | № | Задача | Статус | Примечание |
 |---|---|---|---|
 | 1.1 | Пользовательское соглашение (оферта) | ✅ | `docs/TERMS.md` — заполнить плейсхолдеры, утвердить у юриста |
 | 1.2 | Политика конфиденциальности (152-ФЗ) | ✅ | `docs/PRIVACY.md` — заполнить плейсхолдеры, утвердить у юриста |
 | 1.3 | Текст согласия на обработку ПДн | ✅ | `docs/CONSENT.md` — встроить в форму регистрации |
 | 1.4 | Публикация документов на сайте по постоянным URL | ✅ | RPC `GetTerms`/`GetPrivacy`/`GetConsent` (`api/main.proto`, пути `/api/terms`, `/api/privacy`, `/api/consent`); текст встраивается из `docs/embed.go`; подставить реальные домены в тексты документов |
 ## 2. Акцепт соглашений при регистрации (ст. 428 ГК РФ, ст. 9 152-ФЗ)
 | № | Задача | Статус | Где |
 |---|---|---|---|
 | 2.1 | Поля `accept_terms` / `accept_privacy` в запросе регистрации | ✅ | `api/main.proto` (`SignupReq`), перегенерирован `proto/` |
 | 2.2 | Серверная проверка: регистрация без акцепта отклоняется (`ErrTermsNotAccepted`) | ✅ | `internal/services/users_service/service.go` → `AddUser`; `internal/app/server.go` → `Signup` |
 | 2.3 | Таблица `user_agreements` (user_id, тип, версия, дата, IP, user-agent) | ✅ | `migrations/20260818231943_create_user_agreements_table.sql` |
 | 2.4 | Фиксация акцепта при регистрации (terms + privacy), атомарно с созданием пользователя | ✅ | `users_repo.AddUserWithAgreements` (одна транзакция: пользователь не существует без записей о согласиях) |
 | 2.5 | Версии документов как константы (`termsVersion`, `privacyVersion`) | ✅ | `users_service/service.go` — при новой редакции документов поднять версию |
 | 2.6 | Чекбоксы в форме регистрации (не предустановленные!) + блокировка отправки | ⬜ | Фронтенд (репозиторий фронта) |
 | 2.7 | Возраст 18+ (текст + проверка) | 🟡 | В документах и коде — запрет; проверить, что форма запрашивает подтверждение возраста |
 | 2.8 | Фиксация IP и user-agent клиента при акцепте (ст. 9 ч. 3 152-ФЗ) | ✅ | `clientInfoFromContext`: `X-Real-IP` от доверенного прокси (матчер в `cmd/evening_detective_server/main.go`), иначе последний элемент `X-Forwarded-For`; UA — `grpcgateway-user-agent` |
 ## 3. Удаление аккаунта и данных (ст. 14, 21 152-ФЗ)
 | № | Задача | Статус | Где |
 |---|---|---|---|
 | 3.1 | Эндпоинт `DELETE /api/auth/delete-account` (авторизован JWT) | ✅ | `api/main.proto` (`DeleteAccount`), `internal/app/server.go` |
 | 3.2 | Удаление аккаунта: ПДн удаляются (refresh-токены, учётная запись); записи об акцептах СОХРАНЯЮТСЯ обезличенными (факт/версия/время; `user_id` отвязывается через FK `ON DELETE SET NULL`, `ip`/`user_agent` обнуляются — бремя доказывания согласия на операторе, ст. 9 ч. 4 152-ФЗ) | ✅ | `internal/repos/users_repo/repo.go` → `DeleteUser` (транзакция); миграции `20260818231943_create_user_agreements_table.sql`, `20260818232725_keep_content_on_user_delete.sql` |
 | 3.2а | Подтверждение паролем при удалении аккаунта (защита от удаления чужим обладателем украденного access-токена) | ✅ | HTTP-заголовок `X-Password` (матчер в `cmd/evening_detective_server/main.go`) → `users_service.DeleteAccount` (bcrypt-сверка); пароль не попадает в URL/query |
 | 3.3 | Судьба контента при удалении аккаунта | ✅ | Выбран вариант «отчуждение исключительного права на опубликованные Сценарии»: контент сохраняется, автор не вправе требовать удаления (п. 7.2, 7.6, 7.8 TERMS; ст. 1234, 1269 ГК РФ) |
 | 3.4 | NULL-safe чтение сценариев с обезличенным автором | ✅ | `scenarios_repo` (scan через указатели), `mapUser` возвращает nil → `author: null` в API (клиент показывает «Автор удалён») |
 | 3.5 | Удаление файлов из S3 при удалении аккаунта | ⬜ | Сейчас удаляются только записи в БД; файлы пользователя в S3 (`file_service`) остаются — добавить вызов `fileStorage.Delete` для файлов автора |
 | 3.6 | UI-кнопка «Удалить аккаунт» + подтверждение | ⬜ | Фронтенд |
 | 3.7 | Отзыв согласия без удаления аккаунта (ст. 9 ч. 2, 152-ФЗ) | ⬜ | Опционально: отдельный эндпоинт «отозвать согласие» → прекращение обработки, блокировка аккаунта |
 | 3.8 | Инвалидация выданных access-токенов после удаления аккаунта | 🟡 | JWT без revoke-листа: refresh-токен удаляется сразу, access-токен действует до истечения TTL (3 ч, `processor_jwt`); запросы с устаревшим токеном после удаления получат ошибку FK/«Пользователь не найден». Защита: короткий TTL; при необходимости — версия токена/чёрный список |
 **Примечание по акцептам (п. 3.2):** решение владельца — хранить записи об акцептах обезличенными после удаления аккаунта (факт/версия/время без `user_id`/`ip`/`user_agent`): ст. 9 ч. 4 152-ФЗ возлагает на оператора бремя доказывания получения согласия. Альтернатива, если позже решат уничтожать и их (ст. 21 152-ФЗ): вернуть FK `ON DELETE CASCADE` в миграции `20260818231943` и `DELETE FROM user_agreements WHERE user_id = $1` в `DeleteUser`.
 ## 3а. Отчуждение исключительных прав на сценарии (ст. 1234, 1269 ГК РФ)
 | № | Задача | Статус | Где |
 |---|---|---|---|
 | 3а.1 | Пункт TERMS об отчуждении исключительного права при публикации (безвозмездно, в полном объёме) | ✅ | `docs/TERMS.md` п. 7.2–7.4 |
 | 3а.2 | Запрет автору удалять / снимать с публикации опубликованный сценарий (`ErrScenarioPublished`); ПРАВКА КОНТЕНТА опубликованного сценария РАЗРЕШЕНА владельцу (решение владельца продукта) | ✅ | `internal/services/scenarios_service/service.go`; админ — исключение; guard в SQL от гонки «чтение → запись» для status/delete |
 | 3а.3 | Проверка владельца сценария при всех изменениях (public/draft/delete/update/места) (`ErrScenarioNotOwner`) | ✅ | `internal/services/scenarios_service/service.go` → `getScenarioForChange` |
 | 3а.4 | Право на отзыв ограничено моментом обнародования (ст. 1269 ГК РФ) | ✅ | `docs/TERMS.md` п. 7.6 |
 | 3а.5 | Отдельный чекбокс «передаю исключительные права» при первой публикации + серверная проверка | ⬜ | Фронтенд + бэкенд (сейчас публикация доступна владельцу без доп. подтверждения; добавить `confirm_transfer` в `PublicScenarioReq` при необходимости) |
 | 3а.6 | Проверка владельца при редактировании сценария (UpdateScenario, AddScenarioPlace и др.) | ✅ | `getScenarioForChange` в `internal/services/scenarios_service/service.go`; правка опубликованного разрешена (решение владельца, см. 3а.2) |
 | 3а.7 | Оценка рисков ЗоЗПП (ст. 16) для безвозмездного отчуждения в договоре присоединения | 🟡 | См. «Риски» ниже; при запуске для широкой аудитории — консультация юриста и судебная практика |
 **Риски отчуждения прав в договоре присоединения:**
 - **ЗоЗПП, ст. 16**: безвозмездное отчуждение исключительного права на пользовательский контент в оферте для потребителя может быть оспорено как условие, ущемляющее права потребителя. Снижение риска: отдельное явное подтверждение при публикации, возможность отозвать Сценарий до публикации (черновики не отчуждаются), прозрачное выделение условия.
 - **Личные неимущественные права** (ст. 1265 ГК РФ) не отчуждаются: автор сохраняет право авторства и может требовать его признания — отчуждается только имущественное (исключительное) право.
 - **Право на отзыв** (ст. 1269 ГК РФ) действует только до обнародования — после публикации требования автора об удалении не подлежат удовлетворению (кроме случаев, предусмотренных законом, напр. признание сценария нарушающим права третьих лиц).
 - **Коммерческие организации**: п. 3.1 ст. 1234 ГК РФ запрещает безвозмездное отчуждение исключительного права между коммерческими организациями — не применяется, т.к. пользователи — физические лица.
 ## 4. Регистрация в Роскомнадзоре (ст. 22 152-ФЗ)
 | № | Задача | Статус | Примечание |
 |---|---|---|---|
 | 4.1 | Оценить необходимость уведомления РКН о начале обработки ПДн | 🟡 | Интернет-сервис с автоматизированной обработкой обычно требует уведомления; исключения ч. 2 ст. 22 вряд ли применимы. Подать до запуска в прод |
 | 4.2 | Подать уведомление (портал РКН, форма «оператор ПДн») | ⬜ | Внешняя процедура; оператор — физлицо |
 | 4.3 | Получить и хранить номер уведомления / решение | ⬜ | Приложить к документации |
 ## 5. Локализация баз данных (ст. 18 ч. 5 152-ФЗ)
 | № | Задача | Статус | Где |
 |---|---|---|---|
 | 5.1 | PostgreSQL в РФ | ✅ | `docker-compose-db.yml` / прод-конфигурация — проверить, что БД в РФ |
 | 5.2 | S3 (RustFS) — файлы пользователей | 🟡 | Проверить, где физически находится `S3_HOST` в проде |
 | 5.3 | SMTP-логи переписки | 🟡 | Проверить, не сохраняются ли письма/логи за пределами РФ |
 ## 6. Безопасность (ст. 19 152-ФЗ)
 | № | Задача | Статус | Где |
 |---|---|---|---|
 | 6.1 | Хеширование паролей (bcrypt) | ✅ | `users_service/service.go` |
 | 6.2 | JWT access (3 ч) + refresh (7 дн) с ротацией | ✅ | `processor_jwt` |
 | 6.3 | HTTPS на проде | 🟡 | Через обратный прокси (не в репозитории) |
 | 6.4 | Назначить ответственного за обработку ПДн (ст. 22.1) | ⬜ | Организационный шаг (для физлица-оператора — сам владелец) |
 | 6.5 | Внутренний документ: сроки хранения логов, порядок реагирования на утечки (ст. 21 ч. 3.1 — уведомление РКН за 24 ч) | ⬜ | Организационный шаг |
 | 6.6 | Gateway только за доверенным обратным прокси, перезаписывающим `X-Real-IP` (иначе клиент спуфит IP при акцепте; значения валидируются `netip.ParseAddr`) | 🟡 | Требование к прод-развёртыванию: nginx/Caddy перед `:8090`; настройка не в репозитории |
 ## 7. Права субъекта (ст. 14, 17, 20 152-ФЗ)
 | № | Задача | Статус | Где |
 |---|---|---|---|
 | 7.1 | Эндпоинт «получить свои данные» (GDPR-стиль / ст. 14) | 🟡 | Частично есть `GET /api/users/me`; полная выгрузка ПДн (все таблицы) — добавить |
 | 7.2 | Эндпоинт «изменить email/ник» | ⬜ | Сейчас нет; без него нельзя исполнить «уточнение ПДн» |
 | 7.3 | Эндпоинт «удалить аккаунт» | ✅ | П. 3.1 |
 | 7.4 | Процедура ответа на запросы (10 раб. дней, ст. 20) | ⬜ | Организационный шаг + адрес `[email]` из документов |
 ## 8. Прочее
 | № | Задача | Статус | Примечание |
 |---|---|---|---|
 | 8.1 | Обновление swagger (`cmd/evening_detective_server/main.swagger.json`) | ✅ | Перегенерирован `make generate` |
 | 8.2 | Прогон миграции на реальной БД (`goose up`) | ⬜ | Выполнить на staging перед продом |
 | 8.3 | Интеграционный тест: signup без акцепта → ошибка; delete-account → данные удалены | ⬜ | `go test` (сейчас тестов нет) |
 | 8.4 | Обновить README: новые эндпоинты, документы | ⬜ | — |
 | 8.5 | GDPR (если появятся пользователи из ЕС) | ⬜ | Политика + DPA + механизмы прав субъекта — отдельный этап |
 ---
 ## Порядок действий перед запуском в прод
 1. Заполнить плейсхолдеры в `docs/TERMS.md`, `docs/PRIVACY.md`, `docs/CONSENT.md` и утвердить у юриста.
 2. Вставить в тексты документов реальные домены (`/api/terms`, `/api/privacy`, `/api/consent`); вставить чекбоксы акцепта, подтверждение отчуждения прав при публикации сценария и кнопку «Удалить аккаунт» во фронтенд.
 3. Подать уведомление в Роскомнадзор (п. 4.2) до начала обработки.
 4. Проверить локализацию: БД, S3, SMTP — в РФ.
 5. Прогнать `goose up` на staging; добавить интеграционный тест (п. 8.3) — включая сценарий: публикация → удаление запрещено; удаление аккаунта → сценарий остаётся с `author: null`.
 6. Решить задачу удаления файлов из S3 (п. 3.5) и «изменить email/ник» (п. 7.2) — по остаточному принципу после запуска.
@@ -0,0 +1,54 @@
 # СОГЛАСИЕ НА ОБРАБОТКУ ПЕРСОНАЛЬНЫХ ДАННЫХ
 **Сервис «Вечерний детектив»** · **Редакция от «__» ________ 20__ года**
 *Настоящий документ является шаблоном и носит информационный характер. Перед использованием текст должен быть адаптирован и утверждён квалифицированным юристом.*
 ---
 ## Текст согласия (для регистрационной формы)
 Я, свободно, своей волей и в своём интересе, являясь дееспособным лицом, достигшим возраста 18 лет, даю своё согласие **[ФИО Оператора]** (далее — **Оператор**), зарегистрированному по адресу: **[адрес]**, на обработку моих персональных данных (далее — **ПДн**) в соответствии с Федеральным законом от 27.07.2006 № 152-ФЗ «О персональных данных» (далее — **152-ФЗ**), а именно на совершение действий, предусмотренных п. 3 ч. 1 ст. 3 152-ФЗ, со следующими ПДн:
 1. адрес электронной почты;
 2. имя пользователя (никнейм / псевдоним);
 3. сведения об учётной записи (включая роли и права);
 4. данные об участии в играх, командах, поданных заявках;
 5. создаваемые мной материалы (сценарии, тексты, иной контент);
 6. загружаемые мной файлы;
 7. технические данные (IP-адрес, сведения об устройстве и браузере, файлы cookie);
 8. иные данные, добровольно предоставляемые мной при использовании Сервиса.
 **Цели обработки** ПДн: идентификация и аутентификация при использовании Сервиса «Вечерний детектив»; предоставление доступа к Сервису и его функциям; связь со мной (направление пароля, уведомлений); обеспечение безопасности Сервиса; улучшение качества Сервиса; исполнение требований законодательства РФ.
 **Перечень действий с ПДн:** сбор, запись, систематизация, накопление, хранение, уточнение (обновление, изменение), извлечение, использование, обезличивание, блокирование, удаление, уничтожение, — как с использованием средств автоматизации, так и без их использования.
 Настоящее согласие действует со дня его предоставления до дня его отзыва. Согласие может быть отозвано мной в любое время путём направления Оператору письменного требования (в т.ч. в форме электронного документа) на адрес: **[email]**. При отзыве согласия Оператор обязан прекратить обработку ПДн и уничтожить их в срок, не превышающий 30 (тридцати) календарных дней с даты получения отзыва, если иное не предусмотрено законодательством РФ.
 Я ознакомлен(а) с Политикой конфиденциальности и обработки персональных данных, размещённой по адресу: **[адрес политики]**, и Пользовательским соглашением, размещённым по адресу: **[адрес соглашения]**, и согласен(на) с их условиями.
 «___» ________ 20___ года
 Подпись: ____________________ / ____________________
 ---
 ## Техническая реализация в форме регистрации
 Для юридической значимости согласие должно быть получено до начала обработки и подтверждаемо:
 1. **Чекбоксы с явным согласием** (не предустановленные):
   - [ ] Я принимаю условия [Пользовательского соглашения]
   - [ ] Я даю согласие на обработку персональных данных в соответствии с [Политикой конфиденциальности]
 2. **Блокировка отправки** формы при неотмеченных чекбоксах (клиентская и серверная проверка).
 3. **Серверная проверка**: `POST /api/auth/signup` отклоняет запрос (`accept_terms=false` или `accept_privacy=false`) с ошибкой — уже реализовано в бэкенде (см. `docs/COMPLIANCE.md`).
 4. **Фиксация факта акцепта**: сервер сохраняет запись в таблице `user_agreements` (тип документа, версия, дата, IP, user-agent) — уже реализовано.
 5. **Возраст 18+**: подтверждение возраста включается в текст согласия и регистрационную форму.
 6. **Отдельное подтверждение при публикации Сценария** (рекомендуется): при первом переводе сценария в статус «опубликован» — чекбокс «Я передаю Оператору исключительные права на этот сценарий безвозмездно в полном объёме» с указанием, что после публикации отозвать сценарий нельзя (ст. 1269 ГК РФ). Серверная проверка: `PUT /api/scenarios/{id}/public` отклоняет запрос без этого подтверждения (см. раздел «Риски» в `docs/COMPLIANCE.md`).
 ## Примечания
 - **Отдельное согласие vs соглашение**: согласие на обработку ПДн (ст. 9 152-ФЗ) и акцепт пользовательского соглашения (ст. 428, 1286 ГК РФ) — разные юридические факты, поэтому в форме два отдельных чекбокса.
 - Для несовершеннолетних (до 18 лет) использование Сервиса запрещено (п. 4.1 Пользовательского соглашения); согласие родителей не предусмотрено, т.к. доступ запрещён полностью.
 - При введении платных услуг и изменении целей обработки согласие должно быть переактуализировано.
 - **Удаление аккаунта и контент**: отзыв согласия / удаление Учётной записи влечёт удаление персональных данных, но не прекращает отчуждение исключительного права на опубликованные Сценарии: они остаются в Сервисе, атрибуция обезличивается (п. 7.8 Пользовательского соглашения, ст. 1234 ГК РФ).
@@ -0,0 +1,185 @@
 # ПОЛИТИКА КОНФИДЕНЦИАЛЬНОСТИ И ОБРАБОТКИ ПЕРСОНАЛЬНЫХ ДАННЫХ
 Сервис «Вечерний детектив»
 **Редакция от «__» ________ 20__ года**
 *Настоящий документ является шаблоном и носит информационный характер. Перед публикацией документ должен быть адаптирован и утверждён квалифицированным юристом.*
 ---
 ## 1. Общие положения
 1.1. Настоящая Политика конфиденциальности и обработки персональных данных (далее — **Политика**) определяет порядок и условия обработки персональных данных (далее — **ПДн**) Пользователей Сервиса «Вечерний детектив» (далее — **Сервис**), размещённого в сети Интернет по адресу: **[адрес сайта]**.
 1.2. Оператором ПДн (ст. 3 Федерального закона от 27.07.2006 № 152-ФЗ «О персональных данных», далее — **152-ФЗ**) является **[ФИО Оператора]** (далее — **Оператор**). Реквизиты Оператора указаны в разделе 14 Политики.
 1.3. Политика разработана во исполнение требований ст. 18.1 152-ФЗ и действует в отношении всех ПДн, которые Оператор может получить о Пользователе при использовании Сервиса.
 1.4. Политика является неотъемлемой частью Пользовательского соглашения (далее — **Соглашение**), размещённого по адресу: **[адрес соглашения]**. Термины, используемые в Политике, применяются в значениях, определённых Соглашением, если иное не установлено Политикой или законодательством РФ.
 1.5. Используя Сервис (регистрируясь, авторизуясь, осуществляя доступ к Сервису), Пользователь выражает согласие с условиями Политики и согласие на обработку своих ПДн в порядке и на условиях, изложенных в Политике.
 1.6. Если Пользователь не согласен с условиями Политики, он обязан прекратить использование Сервиса.
 ## 2. Состав обрабатываемых ПДн
 2.1. Оператор обрабатывает следующие ПДн Пользователей:
 2.1.1. **Данные, предоставляемые Пользователем при регистрации и использовании Сервиса:**
 - адрес электронной почты;
 - имя пользователя (никнейм / псевдоним);
 - пароль (в захешированном виде, недоступном для прочтения);
 - иные данные, которые Пользователь добровольно указывает при использовании Сервиса.
 2.1.2. **Данные, создаваемые в процессе использования Сервиса:**
 - сведения об Учётной записи и её настройках;
 - сведения о ролях и правах Пользователя в Сервисе;
 - данные об участии в Играх, о Командах, о поданных заявках;
 - создаваемые Пользователем материалы (Сценарии, тексты, иной Пользовательский контент);
 - загружаемые Пользователем файлы (изображения и иные материалы), в т.ч. при подаче заявок;
 - история действий Пользователя в Сервисе (в т.ч. сведения о входе в Учётную запись).
 2.1.3. **Технические данные, собираемые автоматически:**
 - IP-адрес устройства;
 - данные об устройстве и браузере (тип, версия, язык, разрешение экрана);
 - файлы cookie и аналогичные технологии;
 - сведения о времени и длительности сеансов;
 - иные технические данные, передаваемые устройством Пользователя при обращении к Сервису.
 2.1.4. Оператор не обрабатывает специальные категории ПДн (ст. 10 152-ФЗ: раса, национальность, политические взгляды, религиозные убеждения, состояние здоровья, интимная жизнь) и биометрические ПДн (ст. 11 152-ФЗ), за исключением случаев, прямо предусмотренных законодательством РФ.
 2.1.5. Загружая файлы и размещая Пользовательский контент, Пользователь самостоятельно несёт ответственность за то, чтобы такие материалы не содержали ПДн третьих лиц без их согласия, а также иных сведений, обработка которых не допускается.
 ## 3. Цели обработки ПДн
 3.1. Оператор обрабатывает ПДн Пользователей исключительно в следующих целях:
 - идентификация и аутентификация Пользователя при регистрации и входе в Сервис;
 - предоставление доступа к Сервису и его функциям;
 - обеспечение функционирования Сервиса (в т.ч. создание Игр, Команд, Сценариев, обработка заявок);
 - связь с Пользователем: направление пароля при регистрации, уведомлений о восстановлении пароля, иных служебных сообщений, связанных с использованием Сервиса;
 - обеспечение безопасности Сервиса, защита от несанкционированного доступа, мошенничества и злоупотреблений;
 - улучшение качества Сервиса, анализ использования его функций;
 - исполнение требований законодательства РФ.
 3.2. Оператор не использует ПДн для целей, несовместимых с целями, указанными в п. 3.1 Политики.
 ## 4. Правовые основания обработки ПДн
 4.1. Обработка ПДн Пользователя осуществляется на следующих основаниях (ст. 6 152-ФЗ):
 - **согласие Пользователя** на обработку ПДн, выраженное при регистрации и/или использовании Сервиса (акцепт Политики и Соглашения);
 - **исполнение Соглашения**, стороной которого является Пользователь (в т.ч. предоставление доступа к Сервису, исполнение обязательств Оператора);
 - **исполнение требований законодательства РФ**, возложенных на Оператора;
 - **защита прав и законных интересов** Оператора и третьих лиц (в т.ч. предотвращение злоупотреблений и нарушений).
 4.2. Согласие Пользователя на обработку ПДн является конкретным, информированным и сознательным (ст. 9 152-ФЗ). Согласие может быть отозвано Пользователем в любое время в порядке, предусмотренном разделом 12 Политики.
 ## 5. Порядок и условия обработки ПДн
 5.1. Обработка ПДн осуществляется с использованием средств автоматизации и без использования средств автоматизации, в т.ч. путём сбора, записи, систематизации, накопления, хранения, уточнения (обновления, изменения), извлечения, использования, передачи, обезличивания, блокирования, удаления, уничтожения (ст. 3 152-ФЗ).
 5.2. Обработка ПДн осуществляется с соблюдением принципов, установленных ст. 5 152-ФЗ: законности и справедливости, соответствия целям обработки, минимизации, точности и достаточности, ограничения сроков хранения.
 5.3. Оператор не раскрывает ПДн Пользователей третьим лицам и не распространяет их без согласия Пользователя, за исключением случаев, предусмотренных законодательством РФ.
 5.4. Для обеспечения функционирования Сервиса Оператор может привлекать третьих лиц (технических подрядчиков): поставщиков хостинга и вычислительных мощностей, почтового сервиса для отправки сообщений, сервиса облачного хранения файлов, сервисов аналитики. Передача ПДн таким лицам осуществляется в объёме, необходимом для оказания соответствующих услуг, на основании договоров, содержащих обязательства о конфиденциальности и обеспечении безопасности ПДн (ст. 6, 19 152-ФЗ).
 5.5. ПДн Пользователей не передаются третьим лицам в целях маркетинга и рекламы без отдельного согласия Пользователя.
 ## 6. Файлы cookie и аналитика
 6.1. Сервис может использовать файлы cookie и аналогичные технологии (localStorage, sessionStorage, идентификаторы устройств) для:
 - обеспечения корректной работы Сервиса (технически необходимые cookie);
 - запоминания настроек и предпочтений Пользователя;
 - сбора статистики использования Сервиса (аналитические cookie).
 6.2. Технически необходимые cookie не требуют согласия Пользователя. Использование аналитических и иных необязательных cookie осуществляется с согласия Пользователя, выраженного через настройки браузера и/или элементы интерфейса Сервиса.
 6.3. Пользователь может в любой момент отключить или ограничить использование cookie в настройках браузера. Отключение cookie может повлиять на доступность отдельных функций Сервиса.
 6.4. Данные аналитики могут обрабатываться в обезличенном виде и использоваться для улучшения Сервиса.
 ## 7. Трансграничная передача ПДн
 7.1. На дату вступления Политики в силу трансграничная передача ПДн (ст. 12 152-ФЗ) Оператором не осуществляется.
 7.2. В случае необходимости трансграничной передачи ПДн Оператор обеспечит соблюдение требований ст. 12 152-ФЗ, включая (при необходимости) уведомление или получение разрешения уполномоченного органа (Роскомнадзора) в соответствии с действующим законодательством РФ, и соответствующим образом актуализирует настоящую Политику.
 ## 8. Локализация баз данных
 8.1. Оператор обеспечивает запись, систематизацию, накопление, хранение, уточнение, извлечение ПДн граждан Российской Федерации с использованием баз данных, находящихся на территории Российской Федерации (ст. 18 ч. 5 152-ФЗ).
 ## 9. Меры по защите ПДн
 9.1. Оператор принимает правовые, организационные и технические меры, необходимые и достаточные для обеспечения безопасности ПДн (ст. 19 152-ФЗ), включая:
 - назначение лица, ответственного за организацию обработки ПДн (ст. 22.1 152-ФЗ);
 - применение правовых, организационных и технических мер защиты информации (шифрование паролей, ограничение и разграничение доступа к ПДн, защита каналов передачи данных, резервное копирование);
 - внутренний контроль за соответствием обработки ПДн требованиям законодательства;
 - оценку вреда, который может быть причинён субъектам ПДн в случае нарушения требований 152-ФЗ;
 - ознакомление лиц, допущенных к обработке ПДн, с требованиями законодательства и Политики.
 9.2. Пароли Пользователей хранятся в захешированном виде и недоступны для чтения никому, включая работников и подрядчиков Оператора.
 9.3. При выявлении фактов неправомерной или случайной передачи (предоставления, распространения, доступа) ПДн, повлёкшей нарушение прав субъектов ПДн, Оператор в срок, не превышающий 24 часов, уведомляет уполномоченный орган по защите прав субъектов персональных данных (Роскомнадзор) о произошедшем инциденте, а также в установленных законодательством случаях уведомляет субъектов ПДн (ст. 21 ч. 3.1 152-ФЗ).
 ## 10. Сроки обработки и хранения ПДн
 10.1. ПДн обрабатываются в течение срока, необходимого для достижения целей обработки, либо в течение срока действия Соглашения, если иное не предусмотрено законодательством РФ.
 10.2. ПДн уничтожаются либо обезличиваются по достижении целей обработки, при отзыве Пользователем согласия на обработку ПДн, при удалении Учётной записи, при прекращении Соглашения, а также по требованию Пользователя (ст. 21 152-ФЗ), за исключением случаев, когда законодательством РФ предусмотрено обязательное хранение таких данных в течение определённого срока.
 10.3. При удалении Учётной записи ПДн Пользователя удаляются в срок не более **[30]** календарных дней с момента получения соответствующего требования, если иное не предусмотрено законодательством. Публичный контент Пользователя (опубликованные Сценарии и т.п.) при этом сохраняется в Сервисе: исключительное право на него отчуждено Оператору (п. 7.2 Пользовательского соглашения, ст. 1234 ГК РФ), а связь контента с персональными данными Пользователя прекращается (обезличивание, ст. 3 152-ФЗ).
 ## 11. Защита прав несовершеннолетних
 11.1. Сервис предназначен для лиц, достигших 18 лет (п. 4.1 Соглашения). Регистрация и использование Сервиса лицами, не достигшими 18 лет, запрещены.
 11.2. Оператор не собирает сознательно ПДн лиц, не достигших 18 лет. При обнаружении факта обработки ПДн несовершеннолетнего Оператор незамедлительно прекращает такую обработку и удаляет соответствующие данные.
 ## 12. Права субъекта ПДн и порядок их реализации
 12.1. Пользователь (субъект ПДн) вправе (ст. 14, 17 152-ФЗ):
 - получать информацию, касающуюся обработки его ПДн (сведения, предусмотренные ст. 14 152-ФЗ);
 - требовать уточнения, блокирования или уничтожения своих ПДн, если они являются неполными, устаревшими, неточными, незаконно полученными или не являются необходимыми для заявленной цели обработки (ст. 14, 21 152-ФЗ);
 - отозвать согласие на обработку ПДн в любое время;
 - обжаловать действия (бездействие) Оператора в уполномоченном органе по защите прав субъектов персональных данных (Роскомнадзор) и/или в судебном порядке (ст. 17 152-ФЗ).
 12.2. Для реализации прав, предусмотренных п. 12.1 Политики, Пользователь направляет Оператору запрос в письменной форме (в т.ч. в форме электронного документа) на адрес: **[email]**.
 12.3. Запрос должен содержать (ст. 14 ч. 3, 152-ФЗ):
 - номер основного документа, удостоверяющего личность Пользователя (или его представителя), сведения о дате выдачи и выдавшем органе;
 - сведения, подтверждающие участие Пользователя в отношениях с Оператором (например, адрес электронной почты, использованный при регистрации);
 - подпись Пользователя (или его представителя).
 12.4. Оператор рассматривает запрос и направляет ответ в срок, не превышающий **10 рабочих дней** с даты получения запроса (ст. 20 ч. 1 152-ФЗ). В случае отказа в удовлетворении запроса Оператор направляет мотивированный ответ.
 12.5. Отзыв согласия на обработку ПДн (ст. 9 ч. 2, 152-ФЗ) влечёт прекращение обработки и уничтожение ПДн в срок, не превышающий **30 календарных дней** с даты получения отзыва (ст. 21 ч. 5, 152-ФЗ). Отзыв согласия может сделать невозможным дальнейшее использование Сервиса.
 ## 13. Заключительные положения
 13.1. Оператор вправе в одностороннем порядке изменять условия Политики. Новая редакция Политики вступает в силу с момента её опубликования в Сервисе, если иной срок не указан при опубликовании. Продолжение использования Сервиса после вступления в силу новой редакции Политики означает согласие Пользователя с изменениями.
 13.2. В случае внесения существенных изменений в Политику, затрагивающих права Пользователей, Оператор уведомляет Пользователей способами, доступными в Сервисе (в т.ч. путём направления уведомления на адрес электронной почты).
 13.3. Контроль за соблюдением Политики осуществляет лицо, ответственное за организацию обработки ПДн (п. 9.1 Политики).
 13.4. По всем вопросам, связанным с обработкой ПДн и реализацией прав субъектов ПДн, Пользователь может обратиться к Оператору по адресу: **[email]**.
 13.5. Настоящая Политика регулируется и толкуется в соответствии с законодательством Российской Федерации.
 ## 14. Реквизиты Оператора
 **Оператор Сервиса «Вечерний детектив»:**
 - ФИО: **[ФИО Оператора]**
 - Адрес: **[адрес]**
 - Адрес электронной почты: **[email]**
 - Иные реквизиты: **[ИНН (при наличии), иные сведения]**
 **Адрес для обращений по вопросам обработки персональных данных: [email].**
@@ -0,0 +1,245 @@
 # ПОЛЬЗОВАТЕЛЬСКОЕ СОГЛАШЕНИЕ (ОФЕРТА)
 Сервис «Вечерний детектив»
 **Редакция от «__» ________ 20__ года**
 *Настоящий документ является шаблоном и носит информационный характер. Перед публикацией документ должен быть адаптирован и утверждён квалифицированным юристом.*
 ---
 ## 1. Общие положения
 1.1. Настоящее Пользовательское соглашение (далее — **Соглашение**) является публичной офертой (ст. 435, 437 Гражданского кодекса РФ, далее — ГК РФ) и определяет условия использования Сервиса «Вечерний детектив» (далее — **Сервис**), размещённого в сети Интернет по адресу: **[адрес сайта]**.
 1.2. Оператор Сервиса и правообладатель — **[ФИО Оператора]** (далее — **Оператор**). Реквизиты Оператора указаны в разделе 14 Соглашения.
 1.3. Использование Сервиса регулируется:
 - настоящим Соглашением;
 - Политикой конфиденциальности и обработки персональных данных (далее — **Политика конфиденциальности**), размещённой по адресу: **[адрес политики]**;
 - законодательством Российской Федерации.
 1.4. Соглашение является договором присоединения (ст. 428 ГК РФ). Акцептом Соглашения признаётся совершение Пользователем любого из следующих действий (ст. 438 ГК РФ, ст. 1286 ГК РФ):
 - регистрация учётной записи в Сервисе;
 - начало использования Сервиса (в т.ч. вход в Сервис, создание игры, подача заявки на участие, загрузка материалов);
 - иное действие, свидетельствующее о принятии условий Соглашения.
 1.5. С момента акцепта Соглашение считается заключённым между Пользователем и Оператором в письменной форме (путём обмена документами в электронном виде) на условиях, изложенных в Соглашении, и действует до прекращения в порядке, предусмотренном Соглашением.
 1.6. Оператор вправе в одностороннем порядке изменять условия Соглашения. Новая редакция Соглашения вступает в силу с момента её опубликования в Сервисе, если иной срок не указан при опубликовании. Продолжение использования Сервиса после вступления в силу новой редакции означает согласие Пользователя с изменениями.
 1.7. Если Пользователь не согласен с условиями Соглашения или его изменениями, он обязан прекратить использование Сервиса.
 1.8. Оператор вправе в любое время без уведомления Пользователя вносить изменения в функциональность Сервиса, добавлять или удалять отдельные функции, изменять их содержание.
 ## 2. Термины
 2.1. В целях настоящего Соглашения применяются следующие термины:
 - **Пользователь** — дееспособное физическое лицо, достигшее возраста 18 лет, акцептовавшее Соглашение и использующее Сервис;
 - **Учётная запись (аккаунт)** — совокупность данных Пользователя, создаваемая при регистрации в Сервисе, позволяющая идентифицировать Пользователя;
 - **Игра** — организованное Оператором или Пользователем мероприятие (детективная игра) в рамках Сервиса;
 - **Сценарий** — текстовая и/или мультимедийная основа Игры, создаваемая Оператором или Пользователем;
 - **Команда** — объединение Пользователей для участия в Игре;
 - **Пользовательский контент** — материалы (тексты, изображения, аудио, видео, сценарии, иные объекты), созданные Пользователем и размещённые им в Сервисе;
 - **Личный кабинет** — персонализированный раздел Сервиса, доступный Пользователю после авторизации.
 2.2. Иные термины, не определённые в Соглашении, используются в значениях, установленных законодательством Российской Федерации и Политикой конфиденциальности.
 ## 3. Предмет Соглашения
 3.1. Оператор предоставляет Пользователю доступ к Сервису на условиях простой (неисключительной) лицензии (ст. 1235, 1236 ГК РФ), а Пользователь обязуется использовать Сервис способами, предусмотренными Соглашением.
 3.2. Сервис предоставляет Пользователю возможность:
 - регистрироваться и использовать Учётную запись;
 - создавать Команды и Игры, подавать заявки на участие в Играх;
 - создавать, загружать и использовать Сценарии и иной Пользовательский контент;
 - взаимодействовать с другими Пользователями в рамках Сервиса;
 - использовать иные функции Сервиса по мере их появления.
 3.3. Способы использования Сервиса (ст. 1235 п. 2 ГК РФ): воспроизведение программного обеспечения Сервиса в объёме, необходимом для доступа к Сервису через сеть Интернет, и использование функций Сервиса в соответствии с его назначением. Пользователю не предоставляются права на изменение, распространение, модификацию программного обеспечения Сервиса.
 ## 4. Условия регистрации и Учётная запись
 4.1. Регистрация в Сервисе возможна только для физических лиц, достигших возраста 18 лет. Использование Сервиса лицами, не достигшими 18 лет, запрещено. Регистрируясь, Пользователь подтверждает, что достиг 18 лет и имеет право заключать Соглашение.
 4.2. При регистрации Пользователь предоставляет достоверные данные: адрес электронной почты и иные сведения, запрашиваемые Сервисом. Пользователь несёт ответственность за достоверность предоставленных данных.
 4.3. Пароль для доступа к Учётной записи направляется Пользователю на адрес электронной почты, указанный при регистрации. Пользователь обязан:
 - обеспечить сохранность пароля и не передавать его третьим лицам;
 - незамедлительно уведомить Оператора о любом несанкционированном доступе к Учётной записи;
 - принимать разумные меры для защиты Учётной записи от несанкционированного доступа.
 4.4. Пользователь несёт ответственность за все действия, совершённые с использованием его Учётной записи, если он не докажет, что действия совершены без его участия вследствие обстоятельств непреодолимой силы или вины Оператора.
 4.5. Оператор вправе заблокировать или удалить Учётную запись Пользователя (полностью или частично), а также ограничить доступ к Сервису, в случае нарушения Пользователем условий Соглашения, требований законодательства, а также по иным основаниям, предусмотренным Соглашением. Оператор вправе удалить Учётную запись, не использовавшуюся Пользователем в течение **[12]** месяцев.
 4.6. Учётная запись не может быть передана или отчуждена третьим лицам, за исключением случаев, предусмотренных законом или прямо разрешённых Оператором.
 ## 5. Права и обязанности Пользователя
 5.1. Пользователь вправе:
 - использовать Сервис в соответствии с Соглашением и его назначением;
 - создавать Пользовательский контент и размещать его в Сервисе;
 - обращаться к Оператору по вопросам функционирования Сервиса;
 - реализовывать иные права, предусмотренные Соглашением и законодательством.
 5.2. Пользователь обязуется:
 - соблюдать условия Соглашения, Политики конфиденциальности и требования законодательства РФ;
 - не использовать Сервис для целей, противоречащих законодательству;
 - не совершать действий, направленных на нарушение функционирования Сервиса, его программного обеспечения, баз данных;
 - не пытаться получить несанкционированный доступ к Сервису, его системам и данным других Пользователей;
 - не использовать автоматизированные средства (боты, скрипты, парсеры) для взаимодействия с Сервисом без предварительного письменного разрешения Оператора;
 - не размещать в Сервисе материалы, перечисленные в разделе 6 Соглашения;
 - не воспроизводить, не копировать, не изменять, не декомпилировать, не дизассемблировать программное обеспечение Сервиса, за исключением случаев, прямо разрешённых законом (ст. 1280 ГК РФ);
 - не использовать Сервис для обхода или нарушения прав третьих лиц, включая права на объекты интеллектуальной собственности.
 ## 6. Запрещённый контент и правила поведения
 6.1. В Сервисе запрещено размещение Пользовательского контента, который:
 - нарушает законодательство РФ, в т.ч. авторские и смежные права, права на товарные знаки, иные права третьих лиц;
 - содержит порнографические материалы, а также материалы сексуального характера с участием несовершеннолетних;
 - содержит призывы к насилию, экстремизму, терроризму, разжигание национальной, расовой, религиозной или иной розни;
 - содержит клевету, оскорбления, угрозы, преследование или иным образом нарушает права других лиц;
 - содержит пропаганду наркотических средств, алкоголя, азартных игр (в запрещённых законом формах);
 - содержит вредоносные программы, вирусы, ссылки на них;
 - нарушает права несовершеннолетних;
 - иным образом противоречит целям Сервиса и принципам добросовестности.
 6.2. Оператор вправе, но не обязан, осуществлять модерацию Пользовательского контента. Оператор вправе удалить любой Пользовательский контент, нарушающий условия Соглашения или законодательство, без предварительного уведомления Пользователя, а также заблокировать или удалить Учётную запись нарушителя.
 6.3. Пользователь самостоятельно несёт ответственность за размещаемый им Пользовательский контент, включая его законность, достоверность и соответствие правам третьих лиц.
 ## 7. Пользовательский контент и права на него
 7.1. Личные неимущественные права на Пользовательский контент (право авторства, право на имя) сохраняются за автором и не могут быть отчуждены (ст. 1228, 1265 ГК РФ).
 7.2. Переводя Сценарий в статус «опубликован» (публикуя Сценарий в Сервисе), Пользователь безвозмездно отчуждает Оператору принадлежащее ему исключительное право на такой Сценарий в полном объёме (ст. 1234 ГК РФ). Настоящий договор об отчуждении исключительного права является **безвозмездным**. Исключительное право переходит к Оператору в момент перевода Сценария в статус «опубликован» (ст. 1234 п. 4 ГК РФ), на весь срок действия исключительного права, на территории всего мира. Ограничение п. 3.1 ст. 1234 ГК РФ не применяется, поскольку Пользователь не является коммерческой организацией.
 7.3. Пользователь соглашается с использованием опубликованных Сценариев Оператором без указания имени автора (анонимно) либо под псевдонимом (никнеймом), указанным Пользователем при регистрации (ст. 1265 п. 1 ГК РФ), в т.ч. после удаления Учётной записи Пользователя.
 7.4. Сценарии, не переведённые в статус «опубликован» (черновики), не отчуждаются: Пользователь сохраняет исключительное право на такие Сценарии и вправе свободно их редактировать, изменять и удалять.
 7.5. Пользователь гарантирует, что:
 - он обладает достаточными правами на размещаемый Пользовательский контент (является автором и/или правообладателем либо имеет разрешение правообладателя);
 - размещение контента не нарушает прав третьих лиц и законодательства РФ;
 - контент не содержит персональных данных третьих лиц без их согласия;
 - на момент публикации Сценария он вправе отчуждать исключительное право на него Оператору.
 7.6. Право на отзыв (ст. 1269 ГК РФ) действует только **до фактического обнародования** Сценария. После перевода Сценария в статус «опубликован» Пользователь не вправе отозвать Сценарий, требовать прекращения его использования, удаления или снятия с публикации. Оператор вправе использовать опубликованный Сценарий любыми способами, включая воспроизведение, распространение, переработку, включение в составные и сложные объекты, доведение до всеобщего сведения, предоставление доступа третьим лицам, — без дополнительного согласия Пользователя.
 7.7. При получении претензий третьих лиц в отношении Пользовательского контента Оператор вправе временно ограничить доступ к такому контенту до урегулирования спора и уведомить об этом Пользователя.
 7.8. Удаление Учётной записи Пользователя не прекращает отчуждение исключительного права на опубликованные Сценарии (ст. 1234 п. 1 ГК РФ). При удалении Учётной записи Оператор удаляет персональные данные Пользователя, при этом опубликованные Сценарии сохраняются в Сервисе, а атрибуция автора обезличивается (ст. 3 152-ФЗ, обезличивание) в порядке, предусмотренном п. 7.3 Соглашения.
 ## 8. Платные услуги
 8.1. На дату вступления Соглашения в силу Сервис предоставляется Пользователям бесплатно. Отдельные функции Сервиса могут стать платными в будущем.
 8.2. Оператор вправе вводить платные услуги (функции) Сервиса, а также изменять стоимость платных услуг, уведомив Пользователей не менее чем за **[14]** дней путём опубликования соответствующей информации в Сервисе и/или направления уведомления на адрес электронной почты Пользователя.
 8.3. При введении платных услуг условия их предоставления, включая порядок оплаты, сроки, порядок возврата денежных средств, определяются отдельными документами (правилами), размещаемыми в Сервисе. Использование платных услуг означает согласие Пользователя с соответствующими правилами.
 8.4. Если Сервис будет предоставлять платные услуги, отношения между Оператором и Пользователем в части таких услуг регулируются, в т.ч., Законом РФ от 07.02.1992 № 2300-1 «О защите прав потребителей» (далее — Закон о защите прав потребителей) в части, применимой к отношениям сторон.
 ## 9. Персональные данные
 9.1. При использовании Сервиса Оператор обрабатывает персональные данные Пользователя (ст. 3 Федерального закона от 27.07.2006 № 152-ФЗ «О персональных данных», далее — 152-ФЗ): адрес электронной почты, имя (псевдоним), данные Учётной записи, сведения о действиях Пользователя в Сервисе, технические данные (IP-адрес, файлы cookie, данные об устройстве), иные данные, указанные в Политике конфиденциальности.
 9.2. Обработка персональных данных осуществляется на основании (ст. 6 152-ФЗ):
 - согласия Пользователя, выраженного при регистрации и/или использовании Сервиса (акцепт Политики конфиденциальности);
 - необходимости исполнения Соглашения, стороной которого является Пользователь;
 - иных законных оснований.
 9.3. Цели обработки персональных данных: идентификация Пользователя, предоставление доступа к Сервису, обеспечение функционирования Сервиса, связь с Пользователем (в т.ч. направление пароля и уведомлений), улучшение качества Сервиса, исполнение требований законодательства.
 9.4. Оператор обрабатывает персональные данные в соответствии с принципами законности, справедливости, минимизации и ограничения сроков хранения (ст. 5 152-ФЗ), принимает правовые, организационные и технические меры защиты (ст. 19 152-ФЗ).
 9.5. Пользователь вправе:
 - получать информацию о своих персональных данных и их обработке (ст. 14 152-ФЗ);
 - требовать уточнения, блокирования, уничтожения персональных данных (ст. 14, 21 152-ФЗ);
 - отозвать согласие на обработку персональных данных в любое время (ст. 9 152-ФЗ), направив соответствующее требование Оператору. Отзыв согласия может повлечь невозможность использования Сервиса;
 - обжаловать действия Оператора в уполномоченный орган (Роскомнадзор) и в суд (ст. 17 152-ФЗ).
 9.6. Порядок, сроки и условия обработки персональных данных, включая сведения о cookies и аналитике, подробно изложены в Политике конфиденциальности, размещённой по адресу: **[адрес политики]**.
 9.7. Оператор не передаёт персональные данные Пользователя третьим лицам, за исключением случаев, предусмотренных законодательством РФ или прямо указанных в Политике конфиденциальности (в т.ч. техническим подрядчикам, обеспечивающим функционирование Сервиса).
 9.8. Оператор обеспечивает запись, систематизацию, накопление, хранение, уточнение, извлечение персональных данных граждан Российской Федерации с использованием баз данных, находящихся на территории Российской Федерации (ст. 18 ч. 5 152-ФЗ).
 ## 10. Интеллектуальная собственность
 10.1. Исключительные права на программное обеспечение Сервиса, его дизайн, интерфейс, логотипы, товарные знаки, тексты, базы данных и иные материалы, созданные Оператором (за исключением Пользовательского контента), принадлежат Оператору (ст. 1225, 1229, 1261 ГК РФ).
 10.2. Использование материалов, указанных в п. 10.1, допускается только в пределах функций Сервиса. Запрещается копирование, распространение, переработка, использование материалов Сервиса вне Сервиса без письменного согласия Оператора, за исключением случаев, предусмотренных законодательством.
 10.3. Пользователь обязуется не нарушать исключительные права Оператора и третьих лиц при использовании Сервиса. При нарушении исключительных прав правообладатель вправе требовать защиты способами, предусмотренными ст. 1252, 1301 ГК РФ.
 10.4. Нарушение условий Соглашения о способах использования Сервиса (раздел 3) является нарушением условий лицензии и может являться основанием для её одностороннего прекращения Оператором (ст. 450.1, 1286.1 ГК РФ).
 ## 11. Ответственность сторон
 11.1. За неисполнение или ненадлежащее исполнение обязательств по Соглашению стороны несут ответственность в соответствии с законодательством РФ (ст. 393, 401 ГК РФ).
 11.2. Сервис предоставляется «как есть» (as is). Оператор не гарантирует:
 - бесперебойную и безошибочную работу Сервиса;
 - соответствие Сервиса ожиданиям Пользователя;
 - сохранность Пользовательского контента (Пользователю рекомендуется создавать резервные копии значимых материалов);
 - отсутствие технических сбоев, в т.ч. связанных с работой сети Интернет, хостинга, оборудования.
 11.3. Оператор не несёт ответственности за убытки Пользователя, возникшие в результате:
 - невозможности использования Сервиса по причинам, не зависящим от Оператора;
 - действий (бездействия) Пользователя, включая передачу пароля третьим лицам и нарушение требований безопасности;
 - действий третьих лиц, включая неправомерный доступ к Учётной записи;
 - использования Пользователем Сервиса в целях, не предусмотренных Соглашением.
 11.4. Размер ответственности Оператора по Соглашению ограничивается суммой **[размер, например: фактически уплаченных Пользователем средств за последние 12 месяцев / 10 000 (десять тысяч) рублей]**, за исключением случаев причинения вреда, за которые ограничение ответственности не допускается законом.
 11.5. Оператор не несёт ответственности за действия Пользователей в рамках Игр и за содержание Пользовательского контента.
 11.6. В части платных услуг (раздел 8) положения настоящего раздела применяются с учётом императивных требований Закона о защите прав потребителей.
 ## 12. Изменение, приостановление и прекращение Соглашения
 12.1. Оператор вправе приостановить или прекратить предоставление Сервиса (полностью или частично) в любое время, в т.ч. в связи с техническими, юридическими или коммерческими причинами, уведомив Пользователей способами, доступными в Сервисе.
 12.2. Пользователь вправе в одностороннем порядке отказаться от Соглашения в любое время, прекратив использование Сервиса и (или) удалив Учётную запись.
 12.3. Оператор вправе расторгнуть Соглашение в одностороннем порядке при нарушении Пользователем условий Соглашения, в т.ч. в случаях, указанных в п. 4.5 и п. 6.2 Соглашения, без возмещения каких-либо убытков Пользователю, за исключением случаев, предусмотренных законом.
 12.4. При прекращении Соглашения Пользователь утрачивает право использования Сервиса. Положения Соглашения, которые по своему характеру должны продолжать действовать после прекращения (в т.ч. разделы 7, 9, 10, 11, 13), сохраняют силу.
 ## 13. Разрешение споров
 13.1. Все споры и разногласия, возникающие из Соглашения или в связи с ним, стороны разрешают путём переговоров. Претензионный порядок обязателен: срок рассмотрения претензии — **[30]** календарных дней с момента её получения.
 13.2. При недостижении согласия спор подлежит рассмотрению в суде по месту нахождения Оператора, за исключением случаев, когда в соответствии с законодательством РФ, в т.ч. Законом о защите прав потребителей, предусмотрена подсудность по выбору Пользователя-потребителя (ст. 17 Закона о защите прав потребителей, ст. 29 ГПК РФ).
 13.3. Применимым правом является право Российской Федерации.
 ## 14. Реквизиты Оператора
 **Оператор Сервиса «Вечерний детектив»:**
 - ФИО: **[ФИО Оператора]**
 - Адрес: **[адрес]**
 - Адрес электронной почты: **[email]**
 - Иные реквизиты: **[ИНН (при наличии), иные сведения]**
 **Адрес для обращений по вопросам, связанным с Соглашением и обработкой персональных данных: [email].**
 ---
 *Пользователь подтверждает, что ознакомился с условиями Соглашения, Политикой конфиденциальности, понимает их значение и согласен с ними.*
@@ -0,0 +1,9 @@
 // Package docs встраивает юридические документы в бинарник и раздаёт их
 // по постоянным URL (/terms, /privacy, /consent), на которые сервис
 // ссылается при фиксации акцептов соглашений (user_agreements).
 package docs
 import "embed"
 //go:embed TERMS.md PRIVACY.md CONSENT.md
 var FS embed.FS
@@ -0,0 +1,16 @@
 package docs
 import "testing"
 func TestLegalDocsEmbedded(t *testing.T) {
 	for _, name := range []string{"TERMS.md", "PRIVACY.md", "CONSENT.md"} {
 		data, err := FS.ReadFile(name)
 		if err != nil {
 			t.Errorf("документ %s не встроен: %v", name, err)
 			continue
 		}
 		if len(data) == 0 {
 			t.Errorf("документ %s пустой", name)
 		}
 	}
 }
@@ -3,11 +3,11 @@ module evening_detective_server
 go 1.26
 require (
-	github.com/grpc-ecosystem/grpc-gateway/v2 v2.20.0
+	github.com/grpc-ecosystem/grpc-gateway/v2 v2.30.0
-	github.com/stretchr/testify v1.11.1
+	github.com/stretchr/testify v1.12.0
-	google.golang.org/genproto/googleapis/api v0.0.0-20240513163218-0867130af1f8
+	google.golang.org/genproto/googleapis/api v0.0.0-20260810153831-ec0a7760b754
-	google.golang.org/grpc v1.64.0
+	google.golang.org/grpc v1.83.0
-	google.golang.org/protobuf v1.34.1
+	google.golang.org/protobuf v1.36.11
 )
 require (
@@ -47,11 +47,11 @@ require (
 	github.com/jackc/puddle/v2 v2.2.2 // indirect
 	github.com/joho/godotenv v1.5.1
 	github.com/kzzan/s3kit v0.0.4
-	github.com/swaggest/swgui v1.8.8
+	github.com/swaggest/swgui v1.8.9
-	golang.org/x/crypto v0.53.0
+	golang.org/x/crypto v0.55.0
-	golang.org/x/net v0.55.0 // indirect
+	golang.org/x/net v0.57.0 // indirect
-	golang.org/x/sync v0.21.0 // indirect
+	golang.org/x/sync v0.22.0 // indirect
-	golang.org/x/sys v0.46.0 // indirect
+	golang.org/x/sys v0.47.0 // indirect
-	golang.org/x/text v0.38.0 // indirect
+	golang.org/x/text v0.41.0 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20240513163218-0867130af1f8 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20260807164820-c8921c73eeea // indirect
 )
@@ -0,0 +1,96 @@
 package app
 import (
 	"context"
 	"testing"
 	"google.golang.org/grpc/metadata"
 )
 func TestClientInfoFromContext(t *testing.T) {
 	tests := []struct {
 		name          string
 		md            metadata.MD
 		wantIP        string
 		wantUserAgent string
 	}{
 		{
 			name:          "нет метаданных",
 			wantIP:        "",
 			wantUserAgent: "",
 		},
 		{
 			name: "x-forwarded-for через gateway: берём последний элемент",
 			md: metadata.MD{
 				"x-forwarded-for":        []string{"203.0.113.1, 198.51.100.7"},
 				"grpcgateway-user-agent": []string{"Mozilla/5.0 (test)"},
 			},
 			wantIP:        "198.51.100.7",
 			wantUserAgent: "Mozilla/5.0 (test)",
 		},
 		{
 			name: "x-real-ip от доверенного прокси приоритетнее x-forwarded-for",
 			md: metadata.MD{
 				"x-real-ip":              []string{"192.0.2.10"},
 				"x-forwarded-for":        []string{"203.0.113.1, 10.0.0.1"},
 				"grpcgateway-user-agent": []string{"curl/8.0"},
 			},
 			wantIP:        "192.0.2.10",
 			wantUserAgent: "curl/8.0",
 		},
 		{
 			name: "x-real-ip пустой — фолбэк на x-forwarded-for",
 			md: metadata.MD{
 				"x-real-ip":       []string{" "},
 				"x-forwarded-for": []string{"203.0.113.5"},
 			},
 			wantIP: "203.0.113.5",
 		},
 		{
 			name: "user-agent для прямого gRPC-клиента",
 			md: metadata.MD{
 				"user-agent": []string{"grpc-go/1.60"},
 			},
 			wantUserAgent: "grpc-go/1.60",
 		},
 		{
 			name: "x-forwarded-for с пробелами после запятых",
 			md: metadata.MD{
 				"x-forwarded-for": []string{"203.0.113.1 ,  198.51.100.7 "},
 			},
 			wantIP: "198.51.100.7",
 		},
 		{
 			name: "невалидный x-real-ip — фолбэк на валидный x-forwarded-for",
 			md: metadata.MD{
 				"x-real-ip":       []string{"not-an-ip; drop me"},
 				"x-forwarded-for": []string{"203.0.113.1, 198.51.100.7"},
 			},
 			wantIP: "198.51.100.7",
 		},
 		{
 			name: "все источники невалидны — IP пустой (спуфинг)",
 			md: metadata.MD{
 				"x-real-ip":       []string{"not-an-ip; drop me"},
 				"x-forwarded-for": []string{"256.256.256.256"},
 			},
 			wantIP: "",
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			var ctx context.Context = context.Background()
 			if tt.md != nil {
 				ctx = metadata.NewIncomingContext(ctx, tt.md)
 			}
 			ip, userAgent := clientInfoFromContext(ctx)
 			if ip != tt.wantIP {
 				t.Errorf("ip = %q, want %q", ip, tt.wantIP)
 			}
 			if userAgent != tt.wantUserAgent {
 				t.Errorf("userAgent = %q, want %q", userAgent, tt.wantUserAgent)
 			}
 		})
 	}
 }
@@ -10,6 +10,15 @@ import (
 func mapGame(
 	o *game_service.Game,
 ) *proto.Game {
 	var startedAt *timestamppb.Timestamp
 	if o.StartedAt != nil {
 		startedAt = timestamppb.New(*o.StartedAt)
 	}
 	var endedAt *timestamppb.Timestamp
 	if o.EndedAt != nil {
 		endedAt = timestamppb.New(*o.EndedAt)
 	}
 	return &proto.Game{
 		Id:          int32(o.ID),
 		Name:        o.Name,
@@ -18,6 +27,8 @@ func mapGame(
 		Status:      o.Status,
 		Scenario:    mapScenario(o.Scenario),
 		Teams:       mapTeams(o.Teams),
 		StartedAt:   startedAt,
 		EndedAt:     endedAt,
 	}
 }
@@ -0,0 +1,65 @@
 package app
 import (
 	"context"
 	"strings"
 	"testing"
 	proto "evening_detective_server/proto"
 )
 func TestGetLegalDocs(t *testing.T) {
 	s := &server{}
 	tests := []struct {
 		name     string
 		call     func() (text, errText string)
 		wantPart string
 	}{
 		{
 			name: "GetTerms отдаёт Пользовательское соглашение",
 			call: func() (string, string) {
 				rsp, err := s.GetTerms(context.Background(), &proto.GetTermsReq{})
 				if err != nil {
 					t.Fatalf("GetTerms error: %v", err)
 				}
 				return rsp.Text, rsp.Error
 			},
 			wantPart: "СОГЛАШЕНИЕ",
 		},
 		{
 			name: "GetPrivacy отдаёт Политику конфиденциальности",
 			call: func() (string, string) {
 				rsp, err := s.GetPrivacy(context.Background(), &proto.GetPrivacyReq{})
 				if err != nil {
 					t.Fatalf("GetPrivacy error: %v", err)
 				}
 				return rsp.Text, rsp.Error
 			},
 			wantPart: "КОНФИДЕНЦИАЛЬНОСТИ",
 		},
 		{
 			name: "GetConsent отдаёт текст согласия на обработку ПДн",
 			call: func() (string, string) {
 				rsp, err := s.GetConsent(context.Background(), &proto.GetConsentReq{})
 				if err != nil {
 					t.Fatalf("GetConsent error: %v", err)
 				}
 				return rsp.Text, rsp.Error
 			},
 			wantPart: "СОГЛАСИЕ",
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			text, errText := tt.call()
 			if errText != "" {
 				t.Fatalf("ожидался успех, получена ошибка: %s", errText)
 			}
 			if !strings.Contains(text, tt.wantPart) {
 				t.Errorf("текст документа не содержит %q", tt.wantPart)
 			}
 		})
 	}
 }
@@ -2,9 +2,18 @@ package app
 import (
 	"context"
 	"errors"
 	"fmt"
 	"net/netip"
 	"strings"
 	"evening_detective_server/docs"
 	"evening_detective_server/internal/modules/file_storage"
 	"evening_detective_server/internal/modules/processor_jwt"
 	"evening_detective_server/internal/modules/roles"
 	"evening_detective_server/internal/modules/scenario_archive"
 	"evening_detective_server/internal/modules/string_tools"
 	"evening_detective_server/internal/repos/scenarios_repo"
 	"evening_detective_server/internal/services/file_service"
 	"evening_detective_server/internal/services/game_service"
 	"evening_detective_server/internal/services/scenarios_service"
@@ -13,10 +22,15 @@ import (
 	proto "evening_detective_server/proto"
 	"google.golang.org/genproto/googleapis/api/httpbody"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/metadata"
 	"google.golang.org/grpc/status"
 )
 // stringTools — транслитерация имён файлов для HTTP-заголовков.
 var stringTools = string_tools.NewStringTools()
 type server struct {
 	proto.UnsafeEveningDetectiveServerServer
@@ -52,7 +66,16 @@ func (s *server) Echo(_ context.Context, req *proto.EchoReq) (*proto.EchoRsp, er
 }
 func (s *server) Signup(ctx context.Context, req *proto.SignupReq) (*proto.SignupRsp, error) {
-	err := s.usersService.AddUser(ctx, req.Username, req.Email)
+	ip, userAgent := clientInfoFromContext(ctx)
 	err := s.usersService.AddUser(
 		ctx,
 		req.Username,
 		req.Email,
 		req.AcceptTerms,
 		req.AcceptPrivacy,
 		ip,
 		userAgent,
 	)
 	if err != nil {
 		return &proto.SignupRsp{
 			Error: err.Error(),
@@ -61,6 +84,115 @@ func (s *server) Signup(ctx context.Context, req *proto.SignupReq) (*proto.Signu
 	return &proto.SignupRsp{}, nil
 }
 func (s *server) DeleteAccount(ctx context.Context, req *proto.DeleteAccountReq) (*proto.DeleteAccountRsp, error) {
 	claims, ok := ctx.Value("claims").(*processor_jwt.JWTClaims)
 	if !ok {
 		return nil, status.Errorf(codes.Unauthenticated, "claims is not provided")
 	}
 	// Пароль приходит HTTP-заголовком X-Password (пробрасывается матчером
 	// в main.go), чтобы креденшел не попадал в URL и логи. Для прямых
 	// gRPC-клиентов заголовок передаётся в metadata под тем же ключом.
 	password := ""
 	if md, ok := metadata.FromIncomingContext(ctx); ok {
 		if values := md.Get("x-password"); len(values) > 0 {
 			password = values[0]
 		}
 	}
 	err := s.usersService.DeleteAccount(ctx, claims.UserID, password)
 	if err != nil {
 		return &proto.DeleteAccountRsp{
 			Error: err.Error(),
 		}, nil
 	}
 	return &proto.DeleteAccountRsp{}, nil
 }
 // GetTerms возвращает текст Пользовательского соглашения (постоянный URL
 // /api/terms, на который ссылается форма регистрации при акцепте).
 func (s *server) GetTerms(_ context.Context, _ *proto.GetTermsReq) (*proto.GetTermsRsp, error) {
 	text, err := docs.FS.ReadFile("TERMS.md")
 	if err != nil {
 		return &proto.GetTermsRsp{Error: "Не удалось получить документ"}, nil
 	}
 	return &proto.GetTermsRsp{Text: string(text)}, nil
 }
 // GetPrivacy возвращает текст Политики конфиденциальности (постоянный URL
 // /api/privacy).
 func (s *server) GetPrivacy(_ context.Context, _ *proto.GetPrivacyReq) (*proto.GetPrivacyRsp, error) {
 	text, err := docs.FS.ReadFile("PRIVACY.md")
 	if err != nil {
 		return &proto.GetPrivacyRsp{Error: "Не удалось получить документ"}, nil
 	}
 	return &proto.GetPrivacyRsp{Text: string(text)}, nil
 }
 // GetConsent возвращает текст согласия на обработку персональных данных
 // (постоянный URL /api/consent).
 func (s *server) GetConsent(_ context.Context, _ *proto.GetConsentReq) (*proto.GetConsentRsp, error) {
 	text, err := docs.FS.ReadFile("CONSENT.md")
 	if err != nil {
 		return &proto.GetConsentRsp{Error: "Не удалось получить документ"}, nil
 	}
 	return &proto.GetConsentRsp{Text: string(text)}, nil
 }
 // clientInfoFromContext извлекает IP-адрес и user-agent из gRPC-метаданных.
 //
 // grpc-gateway пробрасывает HTTP-заголовки в метаданные так
 // (runtime.annotateContext / runtime.DefaultHeaderMatcher):
 //   - x-forwarded-for — всегда, при этом gateway дописывает реальный RemoteAddr
 //     клиента последним элементом списка;
 //   - постоянные HTTP-заголовки (включая User-Agent) — с префиксом
 //     grpcgateway-;
 //   - остальные заголовки по умолчанию не пробрасываются: X-Real-IP и
 //     X-Password включаются явным матчером в main.go.
 //
 // Полученный IP валидируется netip.ParseAddr: при прямой экспозиции gateway
 // клиент может подделать эти заголовки, поэтому в БД попадает только
 // корректный адрес.
 func clientInfoFromContext(ctx context.Context) (ip string, userAgent string) {
 	md, ok := metadata.FromIncomingContext(ctx)
 	if !ok {
 		return "", ""
 	}
 	// X-Real-IP от доверенного прокси — приоритетен: в этом случае последним
 	// элементом X-Forwarded-For является адрес прокси, а не клиента.
 	if values := md.Get("x-real-ip"); len(values) > 0 {
 		if v := strings.TrimSpace(values[0]); v != "" {
 			if _, err := netip.ParseAddr(v); err == nil {
 				ip = v
 			}
 		}
 	}
 	if ip == "" {
 		if values := md.Get("x-forwarded-for"); len(values) > 0 {
 			parts := strings.Split(values[0], ",")
 			// Идём с конца списка: последний элемент — реальный RemoteAddr
 			// клиента (первые элементы мог подделать сам клиент).
 			for i := len(parts) - 1; i >= 0; i-- {
 				v := strings.TrimSpace(parts[i])
 				if v == "" {
 					continue
 				}
 				if _, err := netip.ParseAddr(v); err == nil {
 					ip = v
 					break
 				}
 			}
 		}
 	}
 	if values := md.Get("grpcgateway-user-agent"); len(values) > 0 {
 		userAgent = values[0]
 	} else if values := md.Get("user-agent"); len(values) > 0 {
 		userAgent = values[0]
 	}
 	return ip, userAgent
 }
 func (s *server) RefreshPassword(ctx context.Context, req *proto.RefreshPasswordReq) (*proto.RefreshPasswordRsp, error) {
 	err := s.usersService.RefreshPassword(ctx, req.Email)
 	if err != nil {
@@ -299,6 +431,8 @@ func (s *server) UpdateScenario(ctx context.Context, req *proto.UpdateScenarioRe
 		req.Name,
 		req.Description,
 		req.Image,
 		claims.UserID,
 		roles.HasRole(claims, roles.Admin),
 	)
 	if err != nil {
 		return &proto.UpdateScenarioRsp{
@@ -319,6 +453,8 @@ func (s *server) PublicScenario(ctx context.Context, req *proto.PublicScenarioRe
 		ctx,
 		int(req.Id),
 		"public",
 		claims.UserID,
 		roles.HasRole(claims, roles.Admin), // публикация = момент отчуждения прав
 	)
 	if err != nil {
 		return &proto.PublicScenarioRsp{
@@ -331,7 +467,10 @@ func (s *server) PublicScenario(ctx context.Context, req *proto.PublicScenarioRe
 func (s *server) DraftScenario(ctx context.Context, req *proto.DraftScenarioReq) (*proto.DraftScenarioRsp, error) {
 	claims := ctx.Value("claims").(*processor_jwt.JWTClaims)
-	if !roles.HasRole(claims, roles.Author) {
+	// Снять с публикации опубликованный сценарий может только админ:
 	// исключительное право отчуждено Оператору в момент публикации
 	// (п. 7.2 Пользовательского соглашения, ст. 1234, 1269 ГК РФ).
 	if !roles.HasRole(claims, roles.Admin) {
 		return nil, status.Errorf(codes.PermissionDenied, "permission denied")
 	}
@@ -339,6 +478,8 @@ func (s *server) DraftScenario(ctx context.Context, req *proto.DraftScenarioReq)
 		ctx,
 		int(req.Id),
 		"draft",
 		claims.UserID,
 		true,
 	)
 	if err != nil {
 		return &proto.DraftScenarioRsp{
@@ -355,9 +496,13 @@ func (s *server) DeleteScenario(ctx context.Context, req *proto.DeleteScenarioRe
 		return nil, status.Errorf(codes.PermissionDenied, "permission denied")
 	}
 	// Автор не может удалить опубликованный сценарий (исключительное право
 	// отчуждено); админ может.
 	err := s.scenarioService.DeleteScenarioByID(
 		ctx,
 		int(req.Id),
 		claims.UserID,
 		roles.HasRole(claims, roles.Admin),
 	)
 	if err != nil {
 		return &proto.DeleteScenarioRsp{
@@ -378,6 +523,8 @@ func (s *server) AddScenarioPlace(ctx context.Context, req *proto.AddScenarioPla
 		ctx,
 		int(req.Id),
 		convertPlace(req.Place),
 		claims.UserID,
 		roles.HasRole(claims, roles.Admin),
 	)
 	if err != nil {
 		return &proto.AddScenarioPlaceRsp{
@@ -399,6 +546,8 @@ func (s *server) UpdateScenarioPlace(ctx context.Context, req *proto.UpdateScena
 		int(req.Id),
 		req.Code,
 		convertPlace(req.Place),
 		claims.UserID,
 		roles.HasRole(claims, roles.Admin),
 	)
 	if err != nil {
 		return &proto.UpdateScenarioPlaceRsp{
@@ -419,6 +568,8 @@ func (s *server) DeleteScenarioPlace(ctx context.Context, req *proto.DeleteScena
 		ctx,
 		int(req.Id),
 		req.Code,
 		claims.UserID,
 		roles.HasRole(claims, roles.Admin),
 	)
 	if err != nil {
 		return &proto.DeleteScenarioPlaceRsp{
@@ -429,9 +580,85 @@ func (s *server) DeleteScenarioPlace(ctx context.Context, req *proto.DeleteScena
 	return &proto.DeleteScenarioPlaceRsp{}, nil
 }
 // DownloadScenarioArchive отдаёт ZIP-архив сценария; ошибки — gRPC-статусами.
 func (s *server) DownloadScenarioArchive(ctx context.Context, req *proto.DownloadScenarioArchiveReq) (*httpbody.HttpBody, error) {
 	claims := ctx.Value("claims").(*processor_jwt.JWTClaims)
 	if !roles.HasRole(claims, roles.Author) {
 		return nil, status.Errorf(codes.PermissionDenied, "permission denied")
 	}
 	data, name, err := s.scenarioService.DownloadArchive(
 		ctx,
 		int(req.Id),
 		claims.UserID,
 		roles.HasRole(claims, roles.Admin),
 	)
 	if err != nil {
 		switch {
 		case errors.Is(err, scenarios_repo.ErrScenarioNotFound):
 			return nil, status.Errorf(codes.NotFound, "%v", err)
 		case errors.Is(err, scenarios_service.ErrScenarioNotOwner):
 			return nil, status.Errorf(codes.PermissionDenied, "%v", err)
 		default:
 			return nil, status.Errorf(codes.Internal, "%v", err)
 		}
 	}
 	// Имя файла транслитерируется (заголовки HTTP — только ASCII) и
 	// санитайзится от header injection; заголовок пробрасывается gateway.
 	transliterated := sanitizeFilename(stringTools.Transliterate(name))
 	if transliterated == "" {
 		transliterated = "scenario"
 	}
 	filename := transliterated + ".zip"
 	if err := grpc.SetHeader(ctx, metadata.Pairs("Content-Disposition", fmt.Sprintf(`attachment; filename="%s"`, filename))); err != nil {
 		return nil, status.Errorf(codes.Internal, "failed to set response header: %v", err)
 	}
 	return &httpbody.HttpBody{
 		Data:        data,
 		ContentType: "application/zip",
 	}, nil
 }
 // UploadScenarioArchive создаёт сценарий из ZIP-архива. Тело — сырые байты;
 // JSON base64 тоже поддерживается.
 func (s *server) UploadScenarioArchive(ctx context.Context, req *httpbody.HttpBody) (*proto.UploadScenarioArchiveRsp, error) {
 	claims := ctx.Value("claims").(*processor_jwt.JWTClaims)
 	if !roles.HasRole(claims, roles.Author) {
 		return nil, status.Errorf(codes.PermissionDenied, "permission denied")
 	}
 	if req == nil || len(req.Data) == 0 {
 		return nil, status.Errorf(codes.InvalidArgument, "пустое тело запроса")
 	}
 	if len(req.Data) > scenario_archive.MaxArchiveSize() {
 		return nil, status.Errorf(codes.InvalidArgument, "архив больше максимального размера (%d байт)", scenario_archive.MaxArchiveSize())
 	}
 	id, err := s.scenarioService.UploadArchive(ctx, req.Data, claims.UserID)
 	if err != nil {
 		return &proto.UploadScenarioArchiveRsp{
 			Error: err.Error(),
 		}, nil
 	}
 	return &proto.UploadScenarioArchiveRsp{
 		Id: int32(id),
 	}, nil
 }
 // sanitizeFilename — защита от инъекции заголовков в Content-Disposition.
 func sanitizeFilename(name string) string {
 	replacer := strings.NewReplacer(
 		`"`, "_",
 		"\r", "_",
 		"\n", "_",
 	)
 	return replacer.Replace(name)
 }
 func (s *server) AddGame(ctx context.Context, req *proto.AddGameReq) (*proto.AddGameRsp, error) {
 	claims := ctx.Value("claims").(*processor_jwt.JWTClaims)
-	if !roles.HasRole(claims, roles.Organizer) {
+	if !roles.HasRole(claims, roles.Organizer) && !roles.HasRole(claims, roles.Author) {
 		return nil, status.Errorf(codes.PermissionDenied, "permission denied")
 	}
@@ -459,7 +686,7 @@ func (s *server) AddGame(ctx context.Context, req *proto.AddGameReq) (*proto.Add
 func (s *server) DeleteGame(ctx context.Context, req *proto.DeleteGameReq) (*proto.DeleteGameRsp, error) {
 	claims := ctx.Value("claims").(*processor_jwt.JWTClaims)
-	if !roles.HasRole(claims, roles.Organizer) {
+	if !roles.HasRole(claims, roles.Organizer) && !roles.HasRole(claims, roles.Author) {
 		return nil, status.Errorf(codes.PermissionDenied, "permission denied")
 	}
@@ -478,11 +705,11 @@ func (s *server) DeleteGame(ctx context.Context, req *proto.DeleteGameReq) (*pro
 func (s *server) GetGame(ctx context.Context, req *proto.GetGameReq) (*proto.GetGameRsp, error) {
 	claims := ctx.Value("claims").(*processor_jwt.JWTClaims)
-	if !roles.HasRole(claims, roles.Organizer) {
+	if !roles.HasRole(claims, roles.Organizer) && !roles.HasRole(claims, roles.Author) {
 		return nil, status.Errorf(codes.PermissionDenied, "permission denied")
 	}
-	game, err := s.gameService.GetGame(ctx, int(req.Id))
+	game, err := s.gameService.GetFullGame(ctx, int(req.Id))
 	if err != nil {
 		return &proto.GetGameRsp{
 			Error: err.Error(),
@@ -496,7 +723,7 @@ func (s *server) GetGame(ctx context.Context, req *proto.GetGameReq) (*proto.Get
 func (s *server) GetGames(ctx context.Context, req *proto.GetGamesReq) (*proto.GetGamesRsp, error) {
 	claims := ctx.Value("claims").(*processor_jwt.JWTClaims)
-	if !roles.HasRole(claims, roles.Organizer) {
+	if !roles.HasRole(claims, roles.Organizer) && !roles.HasRole(claims, roles.Author) {
 		return nil, status.Errorf(codes.PermissionDenied, "permission denied")
 	}
@@ -514,7 +741,7 @@ func (s *server) GetGames(ctx context.Context, req *proto.GetGamesReq) (*proto.G
 func (s *server) UpdateGame(ctx context.Context, req *proto.UpdateGameReq) (*proto.UpdateGameRsp, error) {
 	claims := ctx.Value("claims").(*processor_jwt.JWTClaims)
-	if !roles.HasRole(claims, roles.Organizer) {
+	if !roles.HasRole(claims, roles.Organizer) && !roles.HasRole(claims, roles.Author) {
 		return nil, status.Errorf(codes.PermissionDenied, "permission denied")
 	}
@@ -539,46 +766,218 @@ func (s *server) UpdateGame(ctx context.Context, req *proto.UpdateGameReq) (*pro
 	return &proto.UpdateGameRsp{}, nil
 }
-func (s *server) AddTeam(ctx context.Context, req *proto.AddTeamReq) (*proto.AddTeamRsp, error) {
+func (s *server) StartGame(ctx context.Context, req *proto.StartGameReq) (*proto.StartGameRsp, error) {
 	claims := ctx.Value("claims").(*processor_jwt.JWTClaims)
-	if !roles.HasRole(claims, roles.Organizer) {
+	if !roles.HasRole(claims, roles.Organizer) && !roles.HasRole(claims, roles.Author) {
 		return nil, status.Errorf(codes.PermissionDenied, "permission denied")
 	}
-	panic("unimplemented")
+	err := s.gameService.StartGame(ctx, int(req.Id))
 	if err != nil {
 		return &proto.StartGameRsp{
 			Error: err.Error(),
 		}, nil
 	}
 	return &proto.StartGameRsp{}, nil
 }
 func (s *server) PauseGame(ctx context.Context, req *proto.PauseGameReq) (*proto.PauseGameRsp, error) {
 	claims := ctx.Value("claims").(*processor_jwt.JWTClaims)
 	if !roles.HasRole(claims, roles.Organizer) && !roles.HasRole(claims, roles.Author) {
 		return nil, status.Errorf(codes.PermissionDenied, "permission denied")
 	}
 	err := s.gameService.PauseGame(ctx, int(req.Id))
 	if err != nil {
 		return &proto.PauseGameRsp{
 			Error: err.Error(),
 		}, nil
 	}
 	return &proto.PauseGameRsp{}, nil
 }
 func (s *server) PlayGame(ctx context.Context, req *proto.PlayGameReq) (*proto.PlayGameRsp, error) {
 	claims := ctx.Value("claims").(*processor_jwt.JWTClaims)
 	if !roles.HasRole(claims, roles.Organizer) && !roles.HasRole(claims, roles.Author) {
 		return nil, status.Errorf(codes.PermissionDenied, "permission denied")
 	}
 	err := s.gameService.PlayGame(ctx, int(req.Id))
 	if err != nil {
 		return &proto.PlayGameRsp{
 			Error: err.Error(),
 		}, nil
 	}
 	return &proto.PlayGameRsp{}, nil
 }
 func (s *server) FinishGame(ctx context.Context, req *proto.FinishGameReq) (*proto.FinishGameRsp, error) {
 	claims := ctx.Value("claims").(*processor_jwt.JWTClaims)
 	if !roles.HasRole(claims, roles.Organizer) && !roles.HasRole(claims, roles.Author) {
 		return nil, status.Errorf(codes.PermissionDenied, "permission denied")
 	}
 	err := s.gameService.FinishGame(ctx, int(req.Id))
 	if err != nil {
 		return &proto.FinishGameRsp{
 			Error: err.Error(),
 		}, nil
 	}
 	return &proto.FinishGameRsp{}, nil
 }
 func (s *server) ResetGame(ctx context.Context, req *proto.ResetGameReq) (*proto.ResetGameRsp, error) {
 	claims := ctx.Value("claims").(*processor_jwt.JWTClaims)
 	if !roles.HasRole(claims, roles.Organizer) && !roles.HasRole(claims, roles.Author) {
 		return nil, status.Errorf(codes.PermissionDenied, "permission denied")
 	}
 	err := s.gameService.ResetGame(ctx, int(req.Id))
 	if err != nil {
 		return &proto.ResetGameRsp{
 			Error: err.Error(),
 		}, nil
 	}
 	return &proto.ResetGameRsp{}, nil
 }
 func (s *server) AddTeam(ctx context.Context, req *proto.AddTeamReq) (*proto.AddTeamRsp, error) {
 	claims := ctx.Value("claims").(*processor_jwt.JWTClaims)
 	if !roles.HasRole(claims, roles.Organizer) && !roles.HasRole(claims, roles.Author) {
 		return nil, status.Errorf(codes.PermissionDenied, "permission denied")
 	}
 	team, err := s.gameService.AddTeam(
 		ctx,
 		claims.UserID,
 		int(req.GameId),
 		req.Name,
 	)
 	if err != nil {
 		return &proto.AddTeamRsp{
 			Error: err.Error(),
 		}, nil
 	}
 	return &proto.AddTeamRsp{
 		Id:       int32(team.ID),
 		Password: team.Password,
 	}, nil
 }
 func (s *server) UpdateTeam(ctx context.Context, req *proto.UpdateTeamReq) (*proto.UpdateTeamRsp, error) {
 	claims := ctx.Value("claims").(*processor_jwt.JWTClaims)
-	if !roles.HasRole(claims, roles.Organizer) {
+	if !roles.HasRole(claims, roles.Organizer) && !roles.HasRole(claims, roles.Author) {
 		return nil, status.Errorf(codes.PermissionDenied, "permission denied")
 	}
-	panic("unimplemented")
+	err := s.gameService.UpdateTeam(
 		ctx,
 		int(req.Id),
 		req.Name,
 	)
 	if err != nil {
 		return &proto.UpdateTeamRsp{
 			Error: err.Error(),
 		}, nil
 	}
 	return &proto.UpdateTeamRsp{}, nil
 }
 func (s *server) DeleteTeam(ctx context.Context, req *proto.DeleteTeamReq) (*proto.DeleteTeamRsp, error) {
 	claims := ctx.Value("claims").(*processor_jwt.JWTClaims)
-	if !roles.HasRole(claims, roles.Organizer) {
+	if !roles.HasRole(claims, roles.Organizer) && !roles.HasRole(claims, roles.Author) {
 		return nil, status.Errorf(codes.PermissionDenied, "permission denied")
 	}
-	panic("unimplemented")
+	err := s.gameService.DeleteTeam(
 		ctx,
 		int(req.Id),
 	)
 	if err != nil {
 		return &proto.DeleteTeamRsp{
 			Error: err.Error(),
 		}, nil
 	}
 	return &proto.DeleteTeamRsp{}, nil
 }
 func (s *server) GiveTeamApplications(ctx context.Context, req *proto.GiveTeamApplicationsReq) (*proto.GiveTeamApplicationsRsp, error) {
 	claims := ctx.Value("claims").(*processor_jwt.JWTClaims)
-	if !roles.HasRole(claims, roles.Organizer) {
+	if !roles.HasRole(claims, roles.Organizer) && !roles.HasRole(claims, roles.Author) {
 		return nil, status.Errorf(codes.PermissionDenied, "permission denied")
 	}
-	panic("unimplemented")
+	err := s.gameService.GiveTeamApplications(
 		ctx,
 		int(req.Id),
 		req.Name,
 	)
 	if err != nil {
 		return &proto.GiveTeamApplicationsRsp{
 			Error: err.Error(),
 		}, nil
 	}
 	return &proto.GiveTeamApplicationsRsp{}, nil
 }
-func (s *server) GetTeamActions(ctx context.Context, req *proto.GetTeamActionsReq) (*proto.GetTeamActionsRsp, error) {
+func (s *server) GetTeamStory(ctx context.Context, req *proto.GetTeamStoryReq) (*proto.GetTeamStoryRsp, error) {
-	panic("unimplemented")
+	story, game, err := s.gameService.GetTeamActions(
 		ctx,
 		int(req.Id),
 		req.Password,
 	)
 	if err != nil {
 		return &proto.GetTeamStoryRsp{
 			Error: err.Error(),
 		}, nil
 	}
 	return &proto.GetTeamStoryRsp{
 		Story: mapStory(story),
 		Game:  mapGame(game),
 	}, nil
 }
 func (s *server) AddTeamAction(ctx context.Context, req *proto.AddTeamActionReq) (*proto.AddTeamActionRsp, error) {
-	panic("unimplemented")
+	err := s.gameService.AddTeamAction(
 		ctx,
 		int(req.Id),
 		req.Password,
 		req.Code,
 	)
 	if err != nil {
 		return &proto.AddTeamActionRsp{
 			Error: err.Error(),
 		}, nil
 	}
 	return &proto.AddTeamActionRsp{}, nil
 }
 func (s *server) DeleteLastTeamAction(ctx context.Context, req *proto.DeleteLastTeamActionReq) (*proto.DeleteLastTeamActionRsp, error) {
 	claims := ctx.Value("claims").(*processor_jwt.JWTClaims)
 	if !roles.HasRole(claims, roles.Author) {
 		return nil, status.Errorf(codes.PermissionDenied, "permission denied")
 	}
 	err := s.gameService.DeleteLastTeamAction(
 		ctx,
 		int(req.Id),
 	)
 	if err != nil {
 		return &proto.DeleteLastTeamActionRsp{
 			Error: err.Error(),
 		}, nil
 	}
 	return &proto.DeleteLastTeamActionRsp{}, nil
 }
@@ -9,6 +9,9 @@ import (
 	"google.golang.org/protobuf/types/known/timestamppb"
 )
 // textFormatter — форматирование текста при конвертации входящих данных.
 var textFormatter = formatter_utils.NewFormatter()
 func mapScenarios(o []*scenarios_service.Scenario) []*proto.Scenario {
 	res := make([]*proto.Scenario, 0, len(o))
 	for _, item := range o {
@@ -117,8 +120,8 @@ func mapKey(o *storytelling.Key) *proto.Key {
 func convertPlace(o *proto.Place) *storytelling.Place {
 	return &storytelling.Place{
 		Code:         o.Code,
-		Name:         formatter_utils.FormatString(o.Name),
+		Name:         textFormatter.FormatString(o.Name),
-		Text:         formatter_utils.FormatText(o.Text),
+		Text:         textFormatter.FormatText(o.Text),
 		Image:        o.Image,
 		Hidden:       o.Hidden,
 		Applications: convertApplications(o.Applications),
@@ -153,7 +156,7 @@ func convertKeys(o []*proto.Key) []*storytelling.Key {
 func convertApplication(o *proto.Application) *storytelling.Application {
 	return &storytelling.Application{
-		Name:  formatter_utils.FormatString(o.Name),
+		Name:  textFormatter.FormatString(o.Name),
 		Image: o.Image,
 	}
 }
@@ -161,13 +164,13 @@ func convertApplication(o *proto.Application) *storytelling.Application {
 func convertDoor(o *proto.Door) *storytelling.Door {
 	return &storytelling.Door{
 		Code: o.Code,
-		Name: formatter_utils.FormatString(o.Name),
+		Name: textFormatter.FormatString(o.Name),
 		Keys: convertKeys(o.Keys),
 	}
 }
 func convertKey(o *proto.Key) *storytelling.Key {
 	return &storytelling.Key{
-		Name: formatter_utils.FormatString(o.Name),
+		Name: textFormatter.FormatString(o.Name),
 	}
 }
@@ -11,6 +11,10 @@ func mapTeam(
 	return &proto.Team{
 		Id:           int32(o.ID),
 		Name:         o.Name,
 		Status:       o.Status,
 		Password:     o.Password,
 		ActionsCount: int32(o.ActionsCount),
 		Applications: mapApplications(o.Applications),
 	}
 }
@@ -7,7 +7,13 @@ import (
 	"google.golang.org/protobuf/types/known/timestamppb"
 )
 // mapUser преобразует пользователя в proto-структуру. Возвращает nil для
 // обезличенного автора (аккаунт удалён, контент сохранён) — клиент отображает
 // такого автора как «Автор удалён».
 func mapUser(o *repos.User) *proto.User {
 	if o == nil {
 		return nil
 	}
 	return &proto.User{
 		Id:        int32(o.ID),
 		Username:  o.Username,
@@ -0,0 +1,37 @@
 package app
 import (
 	"testing"
 	"time"
 	"evening_detective_server/internal/repos"
 )
 func TestMapUser(t *testing.T) {
 	t.Run("nil — обезличенный автор, возвращает nil", func(t *testing.T) {
 		if got := mapUser(nil); got != nil {
 			t.Errorf("mapUser(nil) = %v, want nil", got)
 		}
 	})
 	t.Run("обычный пользователь маппится полностью", func(t *testing.T) {
 		u := &repos.User{
 			ID:        42,
 			Username:  "detective",
 			Email:     "d@example.com",
 			Roles:     []string{"user"},
 			IsActive:  true,
 			CreatedAt: time.Date(2026, 8, 18, 12, 0, 0, 0, time.UTC),
 		}
 		got := mapUser(u)
 		if got == nil {
 			t.Fatal("mapUser вернул nil для не-nil пользователя")
 		}
 		if got.Id != 42 || got.Username != "detective" || got.Email != "d@example.com" {
 			t.Errorf("неожиданный маппинг: %+v", got)
 		}
 		if len(got.Roles) != 1 || got.Roles[0] != "user" {
 			t.Errorf("roles = %v, want [user]", got.Roles)
 		}
 	})
 }
@@ -5,7 +5,11 @@ import "context"
 type Message struct {
 	To      string
 	Subject string
 	// Body — текстовая версия письма (text/plain).
 	Body string
 	// HTML — версия письма для почтовых клиентов (text/html).
 	// Если пусто, письмо уходит только в text/plain.
 	HTML string
 }
 type IEmailSender interface {
@@ -2,9 +2,16 @@ package email_sender
 import (
 	"context"
 	"crypto/rand"
 	"crypto/tls"
 	"errors"
 	"fmt"
 	"mime"
 	"net"
 	"net/mail"
 	"net/smtp"
 	"strings"
 	"time"
 )
 type sender struct {
@@ -12,6 +19,11 @@ type sender struct {
 	smtpPort     string
 	smtpUser     string
 	smtpPassword string
 	from         string
 	fromName     string
 	replyTo      string
 	timeout      time.Duration
 	tlsConfig    *tls.Config
 }
 func NewSender(
@@ -19,76 +31,201 @@ func NewSender(
 	smtpPort string,
 	smtpUser string,
 	smtpPassword string,
 	fromName string,
 	replyTo string,
 	timeout time.Duration,
 ) IEmailSender {
 	// From заголовка письма по умолчанию совпадает с учётной записью SMTP.
 	from := smtpUser
 	if timeout <= 0 {
 		timeout = 10 * time.Second
 	}
 	return &sender{
 		smtpHost:     smtpHost,
 		smtpPort:     smtpPort,
 		smtpUser:     smtpUser,
 		smtpPassword: smtpPassword,
 		from:         from,
 		fromName:     sanitizeHeader(fromName),
 		replyTo:      sanitizeHeader(replyTo),
 		timeout:      timeout,
 		// Проверка имени сервера включена всегда; поле переопределяется
 		// только в тестах (свой RootCAs для самоподписанного сертификата).
 		tlsConfig: &tls.Config{ServerName: smtpHost},
 	}
 }
-func (s *sender) Send(_ context.Context, message Message) error {
+// Send доставляет письмо через SMTP (implicit TLS) с учётом контекста и
-	emailMessage := []byte(fmt.Sprintf(
+// таймаута: соединение устанавливается через DialContext, а все фазы SMTP-
-		"To: %s\r\n"+
+// диалога ограничены общим deadline, производным от ctx.
-			"Subject: %s\r\n"+
+func (s *sender) Send(ctx context.Context, message Message) error {
-			"MIME-Version: 1.0\r\n"+
+	// Санитизация пользовательского ввода: CR/LF/NUL в заголовках ломают
-			"Content-Type: text/plain; charset=utf-8\r\n"+
+	// формат письма и позволяют инъекцию произвольных заголовков (Bcc и т.п.).
-			"\r\n"+
+	to := sanitizeHeader(message.To)
-			"%s\r\n",
+	subject := sanitizeHeader(message.Subject)
-		message.To,
+	if err := validateMessage(to, subject); err != nil {
 		message.Subject,
 		message.Body,
 	))
 	// Настраиваем TLS
 	tlsConfig := &tls.Config{
 		ServerName: s.smtpHost,
 	}
 	// Подключаемся к серверу
 	conn, err := tls.Dial("tcp", s.smtpHost+":"+s.smtpPort, tlsConfig)
 	if err != nil {
 		return err
 	}
-	defer conn.Close()
+	body := buildMessage(s.from, s.fromName, to, subject, s.replyTo, message.Body, message.HTML)
 	ctx, cancel := context.WithTimeout(ctx, s.timeout)
 	defer cancel()
 	addr := net.JoinHostPort(s.smtpHost, s.smtpPort)
 	rawConn, err := (&net.Dialer{}).DialContext(ctx, "tcp", addr)
 	if err != nil {
 		return fmt.Errorf("email: smtp dial %s: %w", addr, err)
 	}
 	defer rawConn.Close()
 	conn := tls.Client(rawConn, s.tlsConfig)
 	if deadline, ok := ctx.Deadline(); ok {
 		// Единый бюджет времени на весь SMTP-диалог: зависший сервер не
 		// должен держать запрос дольше таймаута.
 		if err = conn.SetDeadline(deadline); err != nil {
 			return fmt.Errorf("email: set deadline: %w", err)
 		}
 	}
 	// Создаем SMTP клиент
 	client, err := smtp.NewClient(conn, s.smtpHost)
 	if err != nil {
-		return err
+		return fmt.Errorf("email: smtp greeting: %w", err)
 	}
-	defer client.Quit()
+	// Close гарантированно закрывает соединение при раннем выходе; в конце
 	// штатного пути вместо него вызывается Quit.
 	defer client.Close() //nolint:errcheck
 	// Аутентификация
 	auth := smtp.PlainAuth("", s.smtpUser, s.smtpPassword, s.smtpHost)
 	if err = client.Auth(auth); err != nil {
-		return err
+		return fmt.Errorf("email: smtp auth: %w", err)
 	}
 	if err = client.Mail(s.from); err != nil {
 		return fmt.Errorf("email: smtp mail from: %w", err)
 	}
 	if err = client.Rcpt(to); err != nil {
 		return fmt.Errorf("email: smtp rcpt to: %w", err)
 	}
 	// Указываем отправителя
 	if err = client.Mail(s.smtpUser); err != nil {
 		return err
 	}
 	// Указываем получателя
 	if err = client.Rcpt(message.To); err != nil {
 		return err
 	}
 	// Отправляем данные письма
 	w, err := client.Data()
 	if err != nil {
-		return err
+		return fmt.Errorf("email: smtp data: %w", err)
 	}
-	_, err = w.Write(emailMessage)
+	if _, err = w.Write(body); err != nil {
-	if err != nil {
+		return fmt.Errorf("email: smtp write: %w", err)
 		return err
 	}
-	err = w.Close()
+	if err = w.Close(); err != nil {
-	if err != nil {
+		return fmt.Errorf("email: smtp data close: %w", err)
-		return err
+	}
 	if err = client.Quit(); err != nil {
 		return fmt.Errorf("email: smtp quit: %w", err)
 	}
 	return nil
 }
 // buildMessage собирает тело письма. Заголовки обязаны быть ASCII, поэтому
 // не-ASCII значения (имя отправителя, тема) кодируются по RFC 2047, иначе
 // кириллица может быть испорчена промежуточными серверами. Заголовки
 // Date и Message-ID добавляются явно: их отсутствие — типичный признак
 // спама для почтовых фильтров (включая Gmail). Если задана HTML-версия,
 // письмо собирается как multipart/alternative (text/plain + text/html).
 func buildMessage(from, fromName, to, subject, replyTo, body, html string) []byte {
 	var b strings.Builder
 	b.Grow(len(from) + len(fromName) + len(to) + len(subject) + len(body) + len(html) + 512)
 	b.WriteString("From: ")
 	if fromName != "" {
 		b.WriteString(mime.QEncoding.Encode("utf-8", fromName))
 		b.WriteString(" <")
 		b.WriteString(from)
 		b.WriteString(">\r\n")
 	} else {
 		b.WriteString(from)
 		b.WriteString("\r\n")
 	}
 	b.WriteString("To: ")
 	b.WriteString(to)
 	b.WriteString("\r\n")
 	b.WriteString("Subject: ")
 	b.WriteString(mime.QEncoding.Encode("utf-8", subject))
 	b.WriteString("\r\n")
 	b.WriteString("Date: ")
 	b.WriteString(time.Now().UTC().Format(time.RFC1123Z))
 	b.WriteString("\r\n")
 	b.WriteString("Message-ID: ")
 	b.WriteString(messageID(from))
 	b.WriteString("\r\n")
 	if replyTo != "" {
 		b.WriteString("Reply-To: ")
 		b.WriteString(replyTo)
 		b.WriteString("\r\n")
 	}
 	b.WriteString("MIME-Version: 1.0\r\n")
 	if html == "" {
 		b.WriteString("Content-Type: text/plain; charset=utf-8\r\n")
 		b.WriteString("\r\n")
 		b.WriteString(body)
 		b.WriteString("\r\n")
 		return []byte(b.String())
 	}
 	boundary := fmt.Sprintf("----=_evening_detective_%s", randomHex(10))
 	b.WriteString("Content-Type: multipart/alternative; boundary=\"")
 	b.WriteString(boundary)
 	b.WriteString("\"\r\n\r\n")
 	b.WriteString("--")
 	b.WriteString(boundary)
 	b.WriteString("\r\n")
 	b.WriteString("Content-Type: text/plain; charset=utf-8\r\n")
 	b.WriteString("Content-Transfer-Encoding: 8bit\r\n\r\n")
 	b.WriteString(body)
 	b.WriteString("\r\n--")
 	b.WriteString(boundary)
 	b.WriteString("\r\n")
 	b.WriteString("Content-Type: text/html; charset=utf-8\r\n")
 	b.WriteString("Content-Transfer-Encoding: 8bit\r\n\r\n")
 	b.WriteString(html)
 	b.WriteString("\r\n--")
 	b.WriteString(boundary)
 	b.WriteString("--\r\n")
 	return []byte(b.String())
 }
 // messageID генерирует уникальный Message-ID в домене отправителя.
 func messageID(from string) string {
 	domain := ""
 	if i := strings.LastIndex(from, "@"); i >= 0 && i < len(from)-1 {
 		domain = from[i+1:]
 	}
 	if domain == "" {
 		domain = "localhost"
 	}
 	return "<" + randomHex(12) + "@" + domain + ">"
 }
 // randomHex возвращает случайную hex-строку (криптостойкий генератор;
 // при сбое — значение из таймера, чтобы отправка не падала).
 func randomHex(n int) string {
 	b := make([]byte, n)
 	if _, err := rand.Read(b); err != nil {
 		return fmt.Sprintf("%x", time.Now().UnixNano())
 	}
 	return fmt.Sprintf("%x", b)
 }
 // sanitizeHeader удаляет символы, ломающие структуру заголовков письма
 // (CRLF-инъекция заголовков, NUL).
 func sanitizeHeader(s string) string {
 	r := strings.NewReplacer("\r", "", "\n", "", "\x00", "")
 	return r.Replace(s)
 }
 // validateMessage проверяет адрес получателя и наличие темы до обращения к
 // SMTP-серверу.
 func validateMessage(to, subject string) error {
 	if _, err := mail.ParseAddress(to); err != nil {
 		return fmt.Errorf("email: некорректный адрес получателя: %w", err)
 	}
 	if subject == "" {
 		return errors.New("email: пустая тема письма")
 	}
 	return nil
 }
@@ -0,0 +1,356 @@
 package email_sender
 import (
 	"bufio"
 	"context"
 	"crypto/rand"
 	"crypto/rsa"
 	"crypto/tls"
 	"crypto/x509"
 	"crypto/x509/pkix"
 	"math/big"
 	"net"
 	"strings"
 	"testing"
 	"time"
 )
 // startSMTPTestServer поднимает минимальный SMTP-сервер (implicit TLS) на
 // случайном порту 127.0.0.1 и возвращает его адрес и канал с принятыми
 // телами писем. При hang=true сервер отправляет приветствие и молчит —
 // для проверки таймаутов. Сертификат генерируется один на тест и
 // передаётся и серверу, и клиенту (testSender).
 func startSMTPTestServer(t *testing.T, hang bool, cert tls.Certificate) (addr string, messages chan []byte) {
 	t.Helper()
 	ln, err := tls.Listen("tcp", "127.0.0.1:0", &tls.Config{
 		Certificates: []tls.Certificate{cert},
 	})
 	if err != nil {
 		t.Fatalf("listen: %v", err)
 	}
 	t.Cleanup(func() { _ = ln.Close() })
 	messages = make(chan []byte, 8)
 	go func() {
 		for {
 			conn, err := ln.Accept()
 			if err != nil {
 				return
 			}
 			if hang {
 				go func() {
 					// Приветствие отправляем, дальше молчим.
 					_, _ = conn.Write([]byte("220 hang.example.com ESMTP\r\n"))
 				}()
 				continue
 			}
 			go handleSMTPConn(conn, messages)
 		}
 	}()
 	return ln.Addr().String(), messages
 }
 // handleSMTPConn обслуживает один SMTP-диалог, достаточный для net/smtp:
 // EHLO, AUTH PLAIN, MAIL, RCPT, DATA, QUIT.
 func handleSMTPConn(conn net.Conn, messages chan<- []byte) {
 	defer conn.Close()
 	r := bufio.NewReader(conn)
 	write := func(s string) { _, _ = conn.Write([]byte(s)) }
 	write("220 test.example.com ESMTP\r\n")
 	for {
 		line, err := r.ReadString('\n')
 		if err != nil {
 			return
 		}
 		cmd := strings.ToUpper(strings.TrimSpace(line))
 		switch {
 		case strings.HasPrefix(cmd, "EHLO"):
 			write("250-test.example.com\r\n250-AUTH PLAIN\r\n250 OK\r\n")
 		case strings.HasPrefix(cmd, "AUTH"):
 			write("235 2.7.0 Authentication successful\r\n")
 		case strings.HasPrefix(cmd, "MAIL"):
 			write("250 OK\r\n")
 		case strings.HasPrefix(cmd, "RCPT"):
 			write("250 OK\r\n")
 		case strings.HasPrefix(cmd, "DATA"):
 			write("354 End data with <CR><LF>.<CR><LF>\r\n")
 			var body []byte
 			for {
 				b, err := r.ReadBytes('\n')
 				if err != nil {
 					return
 				}
 				body = append(body, b...)
 				if string(b) == ".\r\n" {
 					break
 				}
 			}
 			select {
 			case messages <- body:
 			default:
 			}
 			write("250 OK\r\n")
 		case strings.HasPrefix(cmd, "QUIT"):
 			write("221 Bye\r\n")
 			return
 		}
 	}
 }
 // testTLSCert генерирует самоподписанный сертификат для 127.0.0.1 и
 // возвращает его вместе с распарсенным x509-представлением (Leaf), чтобы
 // тест мог добавить его в корни доверия клиента.
 func testTLSCert(t *testing.T) tls.Certificate {
 	t.Helper()
 	key, err := rsa.GenerateKey(rand.Reader, 2048)
 	if err != nil {
 		t.Fatalf("generate key: %v", err)
 	}
 	tmpl := &x509.Certificate{
 		SerialNumber:          big.NewInt(1),
 		Subject:               pkix.Name{CommonName: "127.0.0.1"},
 		NotBefore:             time.Now().Add(-time.Hour),
 		NotAfter:              time.Now().Add(time.Hour),
 		IPAddresses:           []net.IP{net.ParseIP("127.0.0.1")},
 		KeyUsage:              x509.KeyUsageCertSign | x509.KeyUsageDigitalSignature,
 		BasicConstraintsValid: true,
 		IsCA:                  true,
 	}
 	der, err := x509.CreateCertificate(rand.Reader, tmpl, tmpl, &key.PublicKey, key)
 	if err != nil {
 		t.Fatalf("create certificate: %v", err)
 	}
 	leaf, err := x509.ParseCertificate(der)
 	if err != nil {
 		t.Fatalf("parse certificate: %v", err)
 	}
 	return tls.Certificate{Certificate: [][]byte{der}, PrivateKey: key, Leaf: leaf}
 }
 // testSender собирает sender, доверяющий самоподписанному сертификату
 // тестового SMTP-сервера (в проде NewSender использует системные корни).
 func testSender(t *testing.T, addr string, timeout time.Duration, cert tls.Certificate) *sender {
 	t.Helper()
 	host, port := splitHostPort(t, addr)
 	pool := x509.NewCertPool()
 	pool.AddCert(cert.Leaf)
 	return &sender{
 		smtpHost:     host,
 		smtpPort:     port,
 		smtpUser:     "sender@example.com",
 		smtpPassword: "secret",
 		from:         "sender@example.com",
 		fromName:     "Вечерний детектив",
 		replyTo:      "support@example.com",
 		timeout:      timeout,
 		tlsConfig:    &tls.Config{ServerName: host, RootCAs: pool},
 	}
 }
 func splitHostPort(t *testing.T, addr string) (host, port string) {
 	t.Helper()
 	host, port, err := net.SplitHostPort(addr)
 	if err != nil {
 		t.Fatalf("split host port: %v", err)
 	}
 	return host, port
 }
 func TestSendSuccess(t *testing.T) {
 	cert := testTLSCert(t)
 	addr, messages := startSMTPTestServer(t, false, cert)
 	s := testSender(t, addr, 5*time.Second, cert)
 	err := s.Send(context.Background(), Message{
 		To:      "user@example.com",
 		Subject: "Привет, детектив!",
 		Body:    "Текст письма",
 		HTML:    "<html><body>Текст письма</body></html>",
 	})
 	if err != nil {
 		t.Fatalf("Send: %v", err)
 	}
 	select {
 	case data := <-messages:
 		raw := string(data)
 		for _, want := range []string{
 			// From с отображаемым именем (RFC 2047).
 			"From: =?utf-8?q?",
 			"<sender@example.com>",
 			"To: user@example.com",
 			"Subject: =?utf-8?q?",
 			"Date: ",
 			"Message-ID: <",
 			"@example.com>",
 			"Reply-To: support@example.com",
 			"MIME-Version: 1.0",
 			"Content-Type: multipart/alternative; boundary=",
 			"Content-Type: text/plain; charset=utf-8",
 			"Текст письма",
 			"Content-Type: text/html; charset=utf-8",
 			"<html><body>Текст письма</body></html>",
 		} {
 			if !strings.Contains(raw, want) {
 				t.Errorf("письмо не содержит %q:\n%s", want, raw)
 			}
 		}
 	case <-time.After(2 * time.Second):
 		t.Fatal("письмо не получено сервером")
 	}
 }
 func TestSendRejectsCRLFInjection(t *testing.T) {
 	cert := testTLSCert(t)
 	addr, messages := startSMTPTestServer(t, false, cert)
 	s := testSender(t, addr, 5*time.Second, cert)
 	// CRLF в адресе — попытка инъекции заголовков (Bcc и т.п.): письмо
 	// должно быть отклонено до обращения к SMTP-серверу.
 	err := s.Send(context.Background(), Message{
 		To:      "user@example.com\r\nBcc: victim@example.com",
 		Subject: "Test",
 		Body:    "body",
 	})
 	if err == nil {
 		t.Fatal("ожидалась ошибка для адреса с CRLF")
 	}
 	select {
 	case <-messages:
 		t.Fatal("письмо не должно было уйти на сервер")
 	default:
 	}
 }
 func TestSendContextCancelled(t *testing.T) {
 	cert := testTLSCert(t)
 	addr, _ := startSMTPTestServer(t, false, cert)
 	s := testSender(t, addr, 10*time.Second, cert)
 	ctx, cancel := context.WithCancel(context.Background())
 	cancel()
 	start := time.Now()
 	err := s.Send(ctx, Message{To: "user@example.com", Subject: "Test", Body: "body"})
 	if err == nil {
 		t.Fatal("ожидалась ошибка при отменённом контексте")
 	}
 	if elapsed := time.Since(start); elapsed > 2*time.Second {
 		t.Fatalf("отмена контекста должна прерывать отправку быстро, заняло %v", elapsed)
 	}
 }
 func TestSendTimeout(t *testing.T) {
 	cert := testTLSCert(t)
 	addr, _ := startSMTPTestServer(t, true, cert) // сервер молчит после приветствия
 	s := testSender(t, addr, 500*time.Millisecond, cert)
 	start := time.Now()
 	err := s.Send(context.Background(), Message{To: "user@example.com", Subject: "Test", Body: "body"})
 	if err == nil {
 		t.Fatal("ожидалась ошибка таймаута")
 	}
 	if elapsed := time.Since(start); elapsed > 3*time.Second {
 		t.Fatalf("таймаут должен сработать быстро, заняло %v", elapsed)
 	}
 }
 func TestBuildMessage(t *testing.T) {
 	// С HTML-версией — multipart/alternative.
 	raw := string(buildMessage(
 		"sender@example.com", "Вечерний детектив",
 		"user@example.com", "Привет", "support@example.com",
 		"текст", "<html><body>текст</body></html>",
 	))
 	for _, want := range []string{
 		"From: =?utf-8?q?",
 		"<sender@example.com>",
 		"To: user@example.com",
 		"Subject: =?utf-8?q?",
 		"Date: ",
 		"Message-ID: <",
 		"Reply-To: support@example.com",
 		"MIME-Version: 1.0",
 		"Content-Type: multipart/alternative; boundary=",
 		"Content-Type: text/plain; charset=utf-8",
 		"текст",
 		"Content-Type: text/html; charset=utf-8",
 		"<html><body>текст</body></html>",
 	} {
 		if !strings.Contains(raw, want) {
 			t.Errorf("письмо не содержит %q:\n%s", want, raw)
 		}
 	}
 	// Без HTML-версии — только text/plain (обратная совместимость).
 	raw = string(buildMessage(
 		"sender@example.com", "Вечерний детектив",
 		"user@example.com", "Привет", "",
 		"текст", "",
 	))
 	for _, want := range []string{
 		"Content-Type: text/plain; charset=utf-8",
 		"текст",
 	} {
 		if !strings.Contains(raw, want) {
 			t.Errorf("plain-письмо не содержит %q:\n%s", want, raw)
 		}
 	}
 	if strings.Contains(raw, "multipart/alternative") {
 		t.Errorf("plain-письмо не должно быть multipart:\n%s", raw)
 	}
 }
 func TestBuildMessageNoFromName(t *testing.T) {
 	raw := string(buildMessage(
 		"sender@example.com", "",
 		"user@example.com", "Привет", "",
 		"текст", "",
 	))
 	if !strings.Contains(raw, "From: sender@example.com\r\n") {
 		t.Errorf("адрес без имени отправителя должен идти без угловых скобок:\n%s", raw)
 	}
 }
 func TestBuildMessageMessageIDDomain(t *testing.T) {
 	raw := string(buildMessage(
 		"evening_detective@crabs-games.art", "Вечерний детектив",
 		"user@example.com", "Привет", "",
 		"текст", "",
 	))
 	for _, want := range []string{
 		"Message-ID: <",
 		"@crabs-games.art>",
 	} {
 		if !strings.Contains(raw, want) {
 			t.Errorf("письмо не содержит %q:\n%s", want, raw)
 		}
 	}
 }
 func TestSanitizeHeader(t *testing.T) {
 	got := sanitizeHeader("a@b.c\r\nBcc: x@y.z\x00")
 	want := "a@b.cBcc: x@y.z"
 	if got != want {
 		t.Errorf("sanitizeHeader = %q, want %q", got, want)
 	}
 }
 func TestValidateMessage(t *testing.T) {
 	if err := validateMessage("user@example.com", "тема"); err != nil {
 		t.Errorf("валидное письмо отклонено: %v", err)
 	}
 	if err := validateMessage("not-an-email", "тема"); err == nil {
 		t.Error("невалидный адрес принят")
 	}
 	if err := validateMessage("user@example.com", ""); err == nil {
 		t.Error("пустая тема принята")
 	}
 }
@@ -11,4 +11,6 @@ type File struct {
 type IFileStorage interface {
 	Put(ctx context.Context, file *File) error
 	Get(ctx context.Context, filename string) (*File, error)
 	Delete(ctx context.Context, filename string) error
 	MimeType(filename string) string
 }
@@ -47,7 +47,7 @@ func NewRustFSStorage(
 }
 func (s *storage) Put(ctx context.Context, file *File) error {
-	mime := s.getMimeType(file.Name)
+	mime := s.MimeType(file.Name)
 	return s.client.PutObjectBytes(ctx, s.bucket, file.Name, file.Data, mime)
 }
@@ -59,11 +59,15 @@ func (s *storage) Get(ctx context.Context, filename string) (*File, error) {
 	return &File{
 		Name: filename,
 		Data: data,
-		Mime: s.getMimeType(filename),
+		Mime: s.MimeType(filename),
 	}, nil
 }
-func (s *storage) getMimeType(filename string) string {
+func (s *storage) Delete(ctx context.Context, filename string) error {
 	return s.client.DeleteObject(ctx, s.bucket, filename)
 }
 func (s *storage) MimeType(filename string) string {
 	if mimeType := mime.TypeByExtension(filepath.Ext(filename)); mimeType != "" {
 		return mimeType
 	}
@@ -0,0 +1,7 @@
 package formatter_utils
 // IFormatter — форматирование текста сценария для отображения.
 type IFormatter interface {
 	FormatText(text string) string
 	FormatString(text string) string
 }
@@ -5,7 +5,16 @@ import (
 	"strings"
 )
-func FormatText(text string) string {
+type formatter struct{}
 // NewFormatter создаёт реализацию IFormatter.
 func NewFormatter() IFormatter {
 	return &formatter{}
 }
 // FormatText форматирует многострочный текст: обрезает пробелы по краям
 // строк, превращает "--" в тире и добавляет отступ абзаца.
 func (f *formatter) FormatText(text string) string {
 	scanner := bufio.NewScanner(strings.NewReader(text))
 	scanner.Split(bufio.ScanLines)
@@ -35,7 +44,9 @@ func FormatText(text string) string {
 	return res.String()
 }
-func FormatString(text string) string {
+// FormatString форматирует одиночную строку: обрезает пробелы и заменяет
 // "--" на тире.
 func (f *formatter) FormatString(text string) string {
 	l := strings.TrimSpace(text)
 	if strings.HasPrefix(l, "--") {
 		l = strings.Replace(l, "--", "—", 1)
@@ -29,9 +29,10 @@ func Test_service_FormatText(t *testing.T) {
 			want: "    — Привет",
 		},
 	}
 	formatter := NewFormatter()
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got := FormatText(tt.text)
+			got := formatter.FormatText(tt.text)
 			if got != tt.want {
 				t.Errorf("FormatText() = %v, want %v", got, tt.want)
 			}
@@ -20,7 +20,6 @@ func NewGenerator(length int) IPasswordGenerator {
 }
 func (g *generator) Generate() (string, error) {
 	return "1", nil
 	password := make([]byte, g.length)
 	for i := range password {
 		num, err := rand.Int(rand.Reader, big.NewInt(int64(len(charset))))
@@ -0,0 +1,22 @@
 package roles
 // Роли пользователей системы.
 const (
 	Admin     = "admin"
 	Author    = "author"
 	Organizer = "organizer"
 	User      = "user"
 )
 // AllRoles — список всех ролей.
 var AllRoles = []string{
 	Admin,
 	Author,
 	Organizer,
 	User,
 }
 // IHasRole — контракт субъекта, у которого можно проверить наличие роли.
 type IHasRole interface {
 	HasRole(role string) bool
 }
@@ -1,23 +1,7 @@
 package roles
-const (
+// HasRole возвращает true, если у субъекта есть роль; администратор
-	Admin     = "admin"
+// проходит проверку любой роли.
 	Author    = "author"
 	Organizer = "organizer"
 	User      = "user"
 )
 var AllRoles = []string{
 	Admin,
 	Author,
 	Organizer,
 	User,
 }
 type IHasRole interface {
 	HasRole(role string) bool
 }
 func HasRole(claims IHasRole, role string) bool {
 	if claims.HasRole(Admin) {
 		return true
@@ -0,0 +1,19 @@
 package roles
 import "slices"
 // subject — реализация IHasRole: субъект с фиксированным набором ролей.
 type subject struct {
 	roles []string
 }
 // NewSubject создаёт субъект с заданными ролями (например, для тестов
 // авторизации или in-memory проверок прав).
 func NewSubject(roles ...string) IHasRole {
 	return &subject{roles: roles}
 }
 // HasRole возвращает true, если роль есть в наборе ролей субъекта.
 func (s *subject) HasRole(role string) bool {
 	return slices.Contains(s.roles, role)
 }
@@ -0,0 +1,25 @@
 package roles
 import "testing"
 func Test_subject_HasRole(t *testing.T) {
 	subject := NewSubject(Author, Organizer)
 	if !subject.HasRole(Author) {
 		t.Errorf("HasRole(%q) = false, want true", Author)
 	}
 	if !subject.HasRole(Organizer) {
 		t.Errorf("HasRole(%q) = false, want true", Organizer)
 	}
 	if subject.HasRole(Admin) {
 		t.Errorf("HasRole(%q) = true, want false", Admin)
 	}
 }
 func Test_subject_HasRoleEmpty(t *testing.T) {
 	subject := NewSubject()
 	if subject.HasRole(User) {
 		t.Errorf("HasRole(%q) = true, want false для субъекта без ролей", User)
 	}
 }
@@ -0,0 +1,325 @@
 // Пакет scenario_archive — сборка и разбор ZIP-архива сценария.
 // Архив: scenario.json (описание и история) + images/<имя> (файлы изображений).
 // Все пути внутри архива относительные.
 package scenario_archive
 import (
 	"archive/zip"
 	"bytes"
 	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
 	"path"
 	"sort"
 	"strings"
 	"time"
 	"evening_detective_server/internal/modules/storytelling"
 	"evening_detective_server/internal/repos"
 )
 // Лимиты на входящие архивы (защита от zip-bomb). Суммарный объём считается
 // по фактически распакованным байтам — размеры в заголовках ZIP подделываются.
 var (
 	maxArchiveSize  = 32 << 20  // 32 МБ — сырой размер архива
 	maxUnpackedSize = 128 << 20 // 128 МБ — суммарный объём распакованного
 	maxEntries      = 500       // число записей
 	maxEntrySize    = 32 << 20  // 32 МБ — размер одной записи
 	maxPackSize     = 256 << 20 // 256 МБ — суммарный объём изображений при сборке
 )
 type scenarioArchive struct{}
 // NewScenarioArchive создаёт реализацию IScenarioArchive.
 func NewScenarioArchive() IScenarioArchive {
 	return &scenarioArchive{}
 }
 // MaxArchiveSize — максимальный размер входящего архива (для проверок
 // в хендлере и на HTTP-слое).
 func MaxArchiveSize() int {
 	return maxArchiveSize
 }
 // ImagePath возвращает путь изображения внутри архива (images/<имя>) и true
 // для ссылок нашего хранилища: относительное имя или URL с доменом (legacy).
 // Внешние URL и пустые ссылки — ("", false): в архив не кладутся.
 func ImagePath(ref, domain string) (string, bool) {
 	ref = strings.TrimPrefix(ref, domain)
 	if ref == "" {
 		return "", false
 	}
 	low := strings.ToLower(ref)
 	if strings.HasPrefix(low, "http://") || strings.HasPrefix(low, "https://") {
 		return "", false
 	}
 	return "images/" + path.Base(ref), true
 }
 // Pack собирает ZIP-архив сценария: ссылки на изображения хранилища
 // переписываются в images/<имя>, файлы запрашиваются через getFile; внешние
 // URL остаются без изменений. Архив детерминирован (порядок записей и метки).
 func (a *scenarioArchive) Pack(
 	ctx context.Context,
 	scenario *repos.Scenario,
 	domain string,
 	getFile func(ctx context.Context, name string) ([]byte, error),
 ) ([]byte, error) {
 	if scenario == nil {
 		return nil, errors.New("сценарий не задан")
 	}
 	story := &storytelling.Story{}
 	if scenario.Scenario != "" {
 		if err := json.Unmarshal([]byte(scenario.Scenario), story); err != nil {
 			return nil, fmt.Errorf("не удалось разобрать историю сценария: %w", err)
 		}
 	}
 	// Имя в хранилище → путь в архиве; конфликт базовых имён — ошибка.
 	archivePathOf := map[string]string{}
 	addRef := func(ref string) error {
 		if ref == "" {
 			return nil
 		}
 		archivePath, ok := ImagePath(ref, domain)
 		if !ok {
 			return nil
 		}
 		if _, exists := archivePathOf[ref]; exists {
 			return nil
 		}
 		for storageName, existingPath := range archivePathOf {
 			if existingPath == archivePath {
 				return fmt.Errorf("конфликт имён изображений в архиве: %q и %q", storageName, ref)
 			}
 		}
 		archivePathOf[ref] = archivePath
 		return nil
 	}
 	if scenario.Image != nil {
 		if err := addRef(*scenario.Image); err != nil {
 			return nil, err
 		}
 	}
 	for _, place := range story.Places {
 		if err := addRef(place.Image); err != nil {
 			return nil, err
 		}
 		for _, application := range place.Applications {
 			if err := addRef(application.Image); err != nil {
 				return nil, err
 			}
 		}
 	}
 	// Загружаем файлы из хранилища (имя = ссылка без домена), с суммарным лимитом.
 	images := make(map[string][]byte, len(archivePathOf))
 	var totalPacked int64
 	for ref, archivePath := range archivePathOf {
 		storageName := strings.TrimPrefix(ref, domain)
 		data, err := getFile(ctx, storageName)
 		if err != nil {
 			return nil, fmt.Errorf("не удалось получить изображение %q: %w", storageName, err)
 		}
 		totalPacked += int64(len(data))
 		if totalPacked > int64(maxPackSize) {
 			return nil, fmt.Errorf("суммарный объём изображений больше %d байт", maxPackSize)
 		}
 		images[archivePath] = data
 	}
 	for _, place := range story.Places {
 		place.Image = rewriteRef(place.Image, archivePathOf)
 		for _, application := range place.Applications {
 			application.Image = rewriteRef(application.Image, archivePathOf)
 		}
 	}
 	doc := ScenarioJSON{
 		Version:     Version,
 		Name:        scenario.Name,
 		Description: strPtrValue(scenario.Description),
 		Story:       story,
 	}
 	if scenario.Image != nil {
 		doc.Image = rewriteRef(*scenario.Image, archivePathOf)
 	}
 	docJSON, err := json.Marshal(doc)
 	if err != nil {
 		return nil, fmt.Errorf("не удалось собрать %s: %w", FileName, err)
 	}
 	var buf bytes.Buffer
 	zw := zip.NewWriter(&buf)
 	if err := writeZipEntry(zw, FileName, docJSON); err != nil {
 		return nil, err
 	}
 	names := make([]string, 0, len(images))
 	for name := range images {
 		names = append(names, name)
 	}
 	sort.Strings(names)
 	for _, name := range names {
 		if err := writeZipEntry(zw, name, images[name]); err != nil {
 			return nil, err
 		}
 	}
 	if err := zw.Close(); err != nil {
 		return nil, fmt.Errorf("не удалось закрыть архив: %w", err)
 	}
 	return buf.Bytes(), nil
 }
 func writeZipEntry(zw *zip.Writer, name string, data []byte) error {
 	header := &zip.FileHeader{
 		Name:   name,
 		Method: zip.Deflate,
 	}
 	// Нулевое время — детерминизм архива между запусками.
 	header.Modified = time.Time{}
 	w, err := zw.CreateHeader(header)
 	if err != nil {
 		return fmt.Errorf("не удалось создать запись %q: %w", name, err)
 	}
 	if _, err := w.Write(data); err != nil {
 		return fmt.Errorf("не удалось записать %q: %w", name, err)
 	}
 	return nil
 }
 func rewriteRef(ref string, archivePathOf map[string]string) string {
 	if ref == "" {
 		return ""
 	}
 	if archivePath, ok := archivePathOf[ref]; ok {
 		return archivePath
 	}
 	return ref
 }
 func strPtrValue(p *string) string {
 	if p == nil {
 		return ""
 	}
 	return *p
 }
 // Unpack разбирает входящий архив с проверкой лимитов и путей записей.
 func (a *scenarioArchive) Unpack(data []byte) (*Bundle, error) {
 	if len(data) == 0 {
 		return nil, errors.New("архив пуст")
 	}
 	if len(data) > maxArchiveSize {
 		return nil, fmt.Errorf("архив больше максимального размера (%d байт)", maxArchiveSize)
 	}
 	zr, err := zip.NewReader(bytes.NewReader(data), int64(len(data)))
 	if err != nil {
 		return nil, fmt.Errorf("не удалось открыть архив: %w", err)
 	}
 	if len(zr.File) > maxEntries {
 		return nil, fmt.Errorf("в архиве больше %d записей", maxEntries)
 	}
 	bundle := &Bundle{Files: make(map[string][]byte, len(zr.File))}
 	var totalUnpacked int64
 	var scenarioRaw []byte
 	for _, f := range zr.File {
 		name := f.Name
 		if f.FileInfo().IsDir() {
 			continue
 		}
 		if err := validateEntryPath(name); err != nil {
 			return nil, err
 		}
 		rc, err := f.Open()
 		if err != nil {
 			return nil, fmt.Errorf("не удалось открыть запись %q: %w", name, err)
 		}
 		content, err := readEntry(rc)
 		rc.Close()
 		if err != nil {
 			return nil, fmt.Errorf("запись %q: %w", name, err)
 		}
 		totalUnpacked += int64(len(content))
 		if totalUnpacked > int64(maxUnpackedSize) {
 			return nil, fmt.Errorf("суммарный размер распакованного архива больше %d байт", maxUnpackedSize)
 		}
 		// Дубли записей отвергаем — «последний победил» портит данные.
 		if name == FileName {
 			if scenarioRaw != nil {
 				return nil, fmt.Errorf("в архиве несколько записей %s", FileName)
 			}
 			scenarioRaw = content
 			continue
 		}
 		if _, exists := bundle.Files[name]; exists {
 			return nil, fmt.Errorf("в архиве несколько записей %q", name)
 		}
 		bundle.Files[name] = content
 	}
 	if scenarioRaw == nil {
 		return nil, fmt.Errorf("в архиве нет файла %s", FileName)
 	}
 	scenario := &ScenarioJSON{}
 	if err := json.Unmarshal(scenarioRaw, scenario); err != nil {
 		return nil, fmt.Errorf("не удалось разобрать %s: %w", FileName, err)
 	}
 	if scenario.Version != Version {
 		return nil, fmt.Errorf("неподдерживаемая версия архива: %d", scenario.Version)
 	}
 	if scenario.Name == "" {
 		return nil, errors.New("в сценарии не указано название")
 	}
 	if scenario.Story == nil {
 		return nil, errors.New("в сценарии не указана история")
 	}
 	bundle.Scenario = scenario
 	return bundle, nil
 }
 // readEntry читает запись с лимитом по фактическим байтам (заголовки ZIP
 // подделываются тривиально).
 func readEntry(r io.Reader) ([]byte, error) {
 	lr := io.LimitReader(r, int64(maxEntrySize)+1)
 	content, err := io.ReadAll(lr)
 	if err != nil {
 		return nil, fmt.Errorf("не удалось прочитать: %w", err)
 	}
 	if int64(len(content)) > int64(maxEntrySize) {
 		return nil, fmt.Errorf("размер больше максимального (%d байт)", maxEntrySize)
 	}
 	return content, nil
 }
 // validateEntryPath отклоняет небезопасные пути записей.
 func validateEntryPath(name string) error {
 	if name == "" {
 		return errors.New("пустое имя записи в архиве")
 	}
 	if strings.Contains(name, "\\") {
 		return fmt.Errorf("недопустимое имя записи в архиве: %q", name)
 	}
 	if strings.HasPrefix(name, "/") {
 		return fmt.Errorf("недопустимое имя записи в архиве: %q", name)
 	}
 	for _, part := range strings.Split(name, "/") {
 		if part == ".." {
 			return fmt.Errorf("недопустимое имя записи в архиве: %q", name)
 		}
 	}
 	if clean := path.Clean(name); clean != name {
 		return fmt.Errorf("недопустимое имя записи в архиве: %q", name)
 	}
 	return nil
 }
@@ -0,0 +1,478 @@
 package scenario_archive
 import (
 	"archive/zip"
 	"bytes"
 	"context"
 	"encoding/json"
 	"fmt"
 	"strings"
 	"testing"
 	"time"
 	"evening_detective_server/internal/modules/storytelling"
 	"evening_detective_server/internal/repos"
 )
 const testDomain = "http://storage.test/api/files/"
 // testArchive — экземпляр модуля для тестов.
 var testArchive = NewScenarioArchive()
 // buildScenario собирает сценарий с историей и ссылками на изображения.
 func buildScenario() *repos.Scenario {
 	description := "Детективная история"
 	image := "cover.png"
 	return &repos.Scenario{
 		ID:          1,
 		Name:        "Ночной клуб",
 		Description: &description,
 		Image:       &image,
 		Scenario: `{"places":[
 			{"code":"club","name":"Клуб","text":"Тёмный зал","image":"club.png","applications":[{"name":"Билет","image":"ticket.jpg"}]},
 			{"code":"parking","name":"Парковка","text":"Пусто","image":"club.png"}
 		]}`,
 	}
 }
 // memoryFiles — замена хранилища для Pack: имя → содержимое.
 type memoryFiles map[string][]byte
 func (m memoryFiles) get(_ context.Context, name string) ([]byte, error) {
 	data, ok := m[name]
 	if !ok {
 		return nil, fmt.Errorf("file not found: %s", name)
 	}
 	return data, nil
 }
 func newMemoryFiles() memoryFiles {
 	return memoryFiles{
 		"cover.png":  []byte("cover-bytes"),
 		"club.png":   []byte("club-bytes"),
 		"ticket.jpg": []byte("ticket-bytes"),
 	}
 }
 func TestPackUnpackRoundTrip(t *testing.T) {
 	files := newMemoryFiles()
 	data, err := testArchive.Pack(context.Background(), buildScenario(), testDomain, files.get)
 	if err != nil {
 		t.Fatalf("Pack: %v", err)
 	}
 	bundle, err := testArchive.Unpack(data)
 	if err != nil {
 		t.Fatalf("Unpack: %v", err)
 	}
 	if bundle.Scenario.Version != Version {
 		t.Errorf("Version = %d, want %d", bundle.Scenario.Version, Version)
 	}
 	if bundle.Scenario.Name != "Ночной клуб" {
 		t.Errorf("Name = %q, want %q", bundle.Scenario.Name, "Ночной клуб")
 	}
 	if bundle.Scenario.Description != "Детективная история" {
 		t.Errorf("Description = %q", bundle.Scenario.Description)
 	}
 	if bundle.Scenario.Image != "images/cover.png" {
 		t.Errorf("Image = %q, want %q", bundle.Scenario.Image, "images/cover.png")
 	}
 	if bundle.Scenario.Story == nil || len(bundle.Scenario.Story.Places) != 2 {
 		t.Fatalf("Story.Places = %+v, want 2 places", bundle.Scenario.Story)
 	}
 	club := bundle.Scenario.Story.Places[0]
 	if club.Image != "images/club.png" {
 		t.Errorf("place image = %q, want %q", club.Image, "images/club.png")
 	}
 	if len(club.Applications) != 1 || club.Applications[0].Image != "images/ticket.jpg" {
 		t.Errorf("application image = %+v, want images/ticket.jpg", club.Applications)
 	}
 	for _, want := range []string{"images/cover.png", "images/club.png", "images/ticket.jpg"} {
 		if _, ok := bundle.Files[want]; !ok {
 			t.Errorf("в архиве нет файла %q", want)
 		}
 	}
 	// Дублирующаяся ссылка (club.png в двух точках) кладётся в архив один раз.
 	if len(bundle.Files) != 3 {
 		t.Errorf("Files = %v, want 3 files", bundle.Files)
 	}
 }
 func TestPackExternalURLsKeptAndNotFetched(t *testing.T) {
 	description := "desc"
 	scenario := &repos.Scenario{
 		ID:          1,
 		Name:        "Внешний",
 		Description: &description,
 		Image:       ptr("https://example.com/cover.png"),
 		Scenario: `{"places":[
 			{"code":"p","name":"P","text":"t","image":"http://other.example/x.png"}
 		]}`,
 	}
 	files := newMemoryFiles()
 	var fetched []string
 	getFile := func(ctx context.Context, name string) ([]byte, error) {
 		fetched = append(fetched, name)
 		return files.get(ctx, name)
 	}
 	data, err := testArchive.Pack(context.Background(), scenario, testDomain, getFile)
 	if err != nil {
 		t.Fatalf("Pack: %v", err)
 	}
 	if len(fetched) != 0 {
 		t.Errorf("getFile вызван для внешних URL: %v", fetched)
 	}
 	bundle, err := testArchive.Unpack(data)
 	if err != nil {
 		t.Fatalf("Unpack: %v", err)
 	}
 	if bundle.Scenario.Image != "https://example.com/cover.png" {
 		t.Errorf("Image = %q, внешний URL должен остаться без изменений", bundle.Scenario.Image)
 	}
 	if bundle.Scenario.Story.Places[0].Image != "http://other.example/x.png" {
 		t.Errorf("place image = %q, внешний URL должен остаться без изменений", bundle.Scenario.Story.Places[0].Image)
 	}
 }
 func TestPackLegacyFullURLImage(t *testing.T) {
 	// Legacy-данные: полный URL хранилища срезается до базового имени файла.
 	description := "desc"
 	scenario := &repos.Scenario{
 		ID:          1,
 		Name:        "Legacy",
 		Description: &description,
 		Image:       ptr(testDomain + "cover.png"),
 		Scenario:    `{"places":[]}`,
 	}
 	data, err := testArchive.Pack(context.Background(), scenario, testDomain, newMemoryFiles().get)
 	if err != nil {
 		t.Fatalf("Pack: %v", err)
 	}
 	bundle, err := testArchive.Unpack(data)
 	if err != nil {
 		t.Fatalf("Unpack: %v", err)
 	}
 	if bundle.Scenario.Image != "images/cover.png" {
 		t.Errorf("Image = %q, want %q", bundle.Scenario.Image, "images/cover.png")
 	}
 }
 func TestPackMissingImage(t *testing.T) {
 	files := newMemoryFiles()
 	delete(files, "ticket.jpg")
 	_, err := testArchive.Pack(context.Background(), buildScenario(), testDomain, files.get)
 	if err == nil {
 		t.Fatal("Pack должен вернуть ошибку при недоступном изображении")
 	}
 	if !strings.Contains(err.Error(), "ticket.jpg") {
 		t.Errorf("ошибка должна содержать имя файла: %v", err)
 	}
 }
 func TestPackDeterministic(t *testing.T) {
 	files := newMemoryFiles()
 	first, err := testArchive.Pack(context.Background(), buildScenario(), testDomain, files.get)
 	if err != nil {
 		t.Fatalf("Pack: %v", err)
 	}
 	time.Sleep(10 * time.Millisecond)
 	second, err := testArchive.Pack(context.Background(), buildScenario(), testDomain, files.get)
 	if err != nil {
 		t.Fatalf("Pack: %v", err)
 	}
 	if !bytes.Equal(first, second) {
 		t.Error("архив недетерминирован: повторный Pack дал другие байты")
 	}
 }
 func TestPackNilScenario(t *testing.T) {
 	_, err := testArchive.Pack(context.Background(), nil, testDomain, nil)
 	if err == nil {
 		t.Fatal("Pack(nil) должен вернуть ошибку")
 	}
 }
 func TestPackImageNameCollision(t *testing.T) {
 	description := "desc"
 	scenario := &repos.Scenario{
 		ID:          1,
 		Name:        "Конфликт",
 		Description: &description,
 		Scenario: `{"places":[
 			{"code":"a","name":"A","text":"t","image":"a.png"},
 			{"code":"b","name":"B","text":"t","image":"dir/a.png"}
 		]}`,
 	}
 	_, err := testArchive.Pack(context.Background(), scenario, testDomain, newMemoryFiles().get)
 	if err == nil {
 		t.Fatal("Pack должен вернуть ошибку при конфликте имён изображений")
 	}
 }
 // writeZip собирает архив с заданными записями (для негативных тестов Unpack).
 func writeZip(t *testing.T, entries map[string][]byte) []byte {
 	t.Helper()
 	var buf bytes.Buffer
 	zw := zip.NewWriter(&buf)
 	for name, content := range entries {
 		w, err := zw.Create(name)
 		if err != nil {
 			t.Fatalf("Create(%q): %v", name, err)
 		}
 		if _, err := w.Write(content); err != nil {
 			t.Fatalf("Write(%q): %v", name, err)
 		}
 	}
 	if err := zw.Close(); err != nil {
 		t.Fatalf("Close: %v", err)
 	}
 	return buf.Bytes()
 }
 // validScenarioJSON — минимальный корректный scenario.json.
 func validScenarioJSON() []byte {
 	b, _ := json.Marshal(ScenarioJSON{
 		Version: Version,
 		Name:    "Тест",
 		Story:   &storytelling.Story{Places: []*storytelling.Place{{Code: "p", Name: "P"}}},
 	})
 	return b
 }
 func TestUnpackRejectsBadPaths(t *testing.T) {
 	for _, name := range []string{
 		"../evil",
 		"a/../../evil",
 		"/abs",
 		"dir\\evil",
 		"a/../b",
 	} {
 		t.Run(name, func(t *testing.T) {
 			data := writeZip(t, map[string][]byte{
 				FileName:       validScenarioJSON(),
 				"images/x.png": []byte("x"),
 				name:           []byte("evil"),
 			})
 			if _, err := testArchive.Unpack(data); err == nil {
 				t.Fatalf("Unpack должен отклонить путь %q", name)
 			}
 		})
 	}
 }
 func TestUnpackEmpty(t *testing.T) {
 	if _, err := testArchive.Unpack(nil); err == nil {
 		t.Fatal("Unpack(nil) должен вернуть ошибку")
 	}
 	if _, err := testArchive.Unpack([]byte{}); err == nil {
 		t.Fatal("testArchive.Unpack(пусто) должен вернуть ошибку")
 	}
 }
 func TestUnpackNotAZip(t *testing.T) {
 	if _, err := testArchive.Unpack([]byte("this is not a zip")); err == nil {
 		t.Fatal("Unpack должен отклонить не-zip данные")
 	}
 }
 func TestUnpackMissingScenarioJSON(t *testing.T) {
 	data := writeZip(t, map[string][]byte{"images/x.png": []byte("x")})
 	if _, err := testArchive.Unpack(data); err == nil {
 		t.Fatal("Unpack должен требовать scenario.json")
 	}
 }
 func TestUnpackInvalidScenarioJSON(t *testing.T) {
 	data := writeZip(t, map[string][]byte{FileName: []byte("{not json")})
 	if _, err := testArchive.Unpack(data); err == nil {
 		t.Fatal("Unpack должен отклонить битый scenario.json")
 	}
 }
 func TestUnpackBadVersion(t *testing.T) {
 	b, _ := json.Marshal(ScenarioJSON{Version: 99, Name: "X", Story: &storytelling.Story{}})
 	data := writeZip(t, map[string][]byte{FileName: b})
 	if _, err := testArchive.Unpack(data); err == nil {
 		t.Fatal("Unpack должен отклонить неизвестную версию")
 	}
 }
 func TestUnpackEmptyName(t *testing.T) {
 	b, _ := json.Marshal(ScenarioJSON{Version: Version, Name: "", Story: &storytelling.Story{}})
 	data := writeZip(t, map[string][]byte{FileName: b})
 	if _, err := testArchive.Unpack(data); err == nil {
 		t.Fatal("Unpack должен требовать название")
 	}
 }
 func TestUnpackNilStory(t *testing.T) {
 	b, _ := json.Marshal(ScenarioJSON{Version: Version, Name: "X"})
 	data := writeZip(t, map[string][]byte{FileName: b})
 	if _, err := testArchive.Unpack(data); err == nil {
 		t.Fatal("Unpack должен требовать story")
 	}
 }
 func TestUnpackEntrySizeLimit(t *testing.T) {
 	prev := maxEntrySize
 	maxEntrySize = 4
 	defer func() { maxEntrySize = prev }()
 	data := writeZip(t, map[string][]byte{
 		FileName:         validScenarioJSON(),
 		"images/big.png": bytes.Repeat([]byte("x"), 8),
 	})
 	if _, err := testArchive.Unpack(data); err == nil {
 		t.Fatal("Unpack должен отклонить запись больше maxEntrySize")
 	}
 }
 func TestUnpackTotalSizeLimit(t *testing.T) {
 	prev := maxUnpackedSize
 	maxUnpackedSize = 6
 	defer func() { maxUnpackedSize = prev }()
 	data := writeZip(t, map[string][]byte{
 		FileName:       validScenarioJSON(),
 		"images/a.png": []byte("aaa"),
 		"images/b.png": []byte("bbb"),
 	})
 	if _, err := testArchive.Unpack(data); err == nil {
 		t.Fatal("Unpack должен отклонить суммарный объём больше maxUnpackedSize")
 	}
 }
 func TestUnpackArchiveSizeLimit(t *testing.T) {
 	prev := maxArchiveSize
 	maxArchiveSize = 4
 	defer func() { maxArchiveSize = prev }()
 	data := writeZip(t, map[string][]byte{FileName: validScenarioJSON()})
 	if _, err := testArchive.Unpack(data); err == nil {
 		t.Fatal("Unpack должен отклонить архив больше maxArchiveSize")
 	}
 }
 func TestUnpackEntriesLimit(t *testing.T) {
 	prev := maxEntries
 	maxEntries = 2
 	defer func() { maxEntries = prev }()
 	data := writeZip(t, map[string][]byte{
 		FileName:       validScenarioJSON(),
 		"images/a.png": []byte("a"),
 		"images/b.png": []byte("b"),
 	})
 	if _, err := testArchive.Unpack(data); err == nil {
 		t.Fatal("Unpack должен отклонить архив с числом записей больше maxEntries")
 	}
 }
 func TestUnpackRejectsDuplicateScenarioJSON(t *testing.T) {
 	var buf bytes.Buffer
 	zw := zip.NewWriter(&buf)
 	for i := 0; i < 2; i++ {
 		w, err := zw.Create(FileName)
 		if err != nil {
 			t.Fatalf("Create: %v", err)
 		}
 		if _, err := w.Write(validScenarioJSON()); err != nil {
 			t.Fatalf("Write: %v", err)
 		}
 	}
 	if err := zw.Close(); err != nil {
 		t.Fatalf("Close: %v", err)
 	}
 	if _, err := testArchive.Unpack(buf.Bytes()); err == nil {
 		t.Fatal("Unpack должен отклонить дубли scenario.json")
 	}
 }
 func TestUnpackRejectsDuplicateFiles(t *testing.T) {
 	var buf bytes.Buffer
 	zw := zip.NewWriter(&buf)
 	for i := 0; i < 3; i++ {
 		name := FileName
 		content := validScenarioJSON()
 		switch i {
 		case 1:
 			name = "images/x.png"
 			content = []byte("x")
 		case 2:
 			// Дубль записи images/x.png.
 			name = "images/x.png"
 			content = []byte("y")
 		}
 		w, err := zw.Create(name)
 		if err != nil {
 			t.Fatalf("Create: %v", err)
 		}
 		if _, err := w.Write(content); err != nil {
 			t.Fatalf("Write: %v", err)
 		}
 	}
 	if err := zw.Close(); err != nil {
 		t.Fatalf("Close: %v", err)
 	}
 	if _, err := testArchive.Unpack(buf.Bytes()); err == nil {
 		t.Fatal("Unpack должен отклонить дубли файлов")
 	}
 }
 func TestPackTotalSizeLimit(t *testing.T) {
 	prev := maxPackSize
 	maxPackSize = 8
 	defer func() { maxPackSize = prev }()
 	description := "desc"
 	scenario := &repos.Scenario{
 		ID:          1,
 		Name:        "Большой",
 		Description: &description,
 		Scenario: `{"places":[
 			{"code":"a","name":"A","text":"t","image":"a.png"},
 			{"code":"b","name":"B","text":"t","image":"b.png"}
 		]}`,
 	}
 	files := memoryFiles{
 		"a.png": bytes.Repeat([]byte("x"), 6),
 		"b.png": bytes.Repeat([]byte("y"), 6),
 	}
 	if _, err := testArchive.Pack(context.Background(), scenario, testDomain, files.get); err == nil {
 		t.Fatal("Pack должен отклонить суммарный объём больше maxPackSize")
 	}
 }
 func TestImagePath(t *testing.T) {
 	cases := []struct {
 		ref    string
 		domain string
 		want   string
 		ok     bool
 	}{
 		{"cover.png", "", "images/cover.png", true},
 		{"dir/cover.png", "", "images/cover.png", true},
 		{testDomain + "cover.png", testDomain, "images/cover.png", true},
 		{"", "", "", false},
 		{"http://example.com/x.png", "", "", false},
 		{"https://example.com/x.png", testDomain, "", false},
 	}
 	for _, tc := range cases {
 		got, ok := ImagePath(tc.ref, tc.domain)
 		if got != tc.want || ok != tc.ok {
 			t.Errorf("ImagePath(%q, %q) = (%q, %v), want (%q, %v)",
 				tc.ref, tc.domain, got, ok, tc.want, tc.ok)
 		}
 	}
 }
 func ptr(s string) *string { return &s }
@@ -0,0 +1,47 @@
 package scenario_archive
 import (
 	"context"
 	"evening_detective_server/internal/modules/storytelling"
 	"evening_detective_server/internal/repos"
 )
 // Имя файла с описанием сценария внутри архива.
 const FileName = "scenario.json"
 // Текущая версия формата scenario.json.
 const Version = 1
 // ScenarioJSON — описание сценария в архиве; Story — в формате колонки
 // scenarios.scenario в БД.
 type ScenarioJSON struct {
 	Version     int                 `json:"version"`
 	Name        string              `json:"name"`
 	Description string              `json:"description,omitempty"`
 	Image       string              `json:"image,omitempty"`
 	Story       *storytelling.Story `json:"story"`
 }
 // Bundle — результат разбора входящего архива.
 type Bundle struct {
 	Scenario *ScenarioJSON
 	Files    map[string][]byte
 }
 // IScenarioArchive — контракт модуля scenario_archive: сборка и разбор
 // ZIP-архива сценария.
 type IScenarioArchive interface {
 	// Pack собирает ZIP-архив сценария: ссылки на изображения хранилища
 	// переписываются в images/<имя>, файлы запрашиваются через getFile;
 	// внешние URL остаются без изменений.
 	Pack(
 		ctx context.Context,
 		scenario *repos.Scenario,
 		domain string,
 		getFile func(ctx context.Context, name string) ([]byte, error),
 	) ([]byte, error)
 	// Unpack разбирает входящий архив с проверкой лимитов и путей записей.
 	Unpack(data []byte) (*Bundle, error)
 }
@@ -0,0 +1,6 @@
 package storytelling
 type ICleaner interface {
 	ClearCode(code string) string
 	ClearText(text string) string
 }
@@ -1,9 +1,15 @@
 package storytelling
-type story struct{}
+type story struct {
 	cleaner ICleaner
 }
-func NewStory() IStory {
+func NewStory(
-	return &story{}
+	cleaner ICleaner,
 ) IStory {
 	return &story{
 		cleaner: cleaner,
 	}
 }
 func (s *story) GetStory(
@@ -69,7 +75,7 @@ func (s *story) findPlace(
 	code string,
 ) (*Place, bool) {
 	for _, place := range scenario.Places {
-		if place.Code == code {
+		if s.cleaner.ClearCode(place.Code) == s.cleaner.ClearCode(code) {
 			return place, true
 		}
 	}
@@ -95,7 +101,7 @@ func (s *story) findResultPlace(
 		}
 	}
 	for _, place := range scenario.Places {
-		if place.Code == code {
+		if s.cleaner.ClearCode(place.Code) == s.cleaner.ClearCode(code) {
 			if place.Hidden && !open {
 				return nil, false
 			}
@@ -130,7 +136,7 @@ func (s *story) mapPlace(
 			applications = append(
 				applications,
 				&Application{
-					Name:  application.Name,
+					Name:  s.cleaner.ClearText(application.Name),
 					Image: application.Image,
 				},
 			)
@@ -175,7 +181,7 @@ func (s *story) mapPlace(
 	return &Place{
 		Code:         place.Code,
 		Name:         place.Name,
-		Text:         place.Text,
+		Text:         s.cleaner.ClearText(place.Text),
 		Image:        place.Image,
 		Applications: applications,
 		Doors:        doors,
@@ -1,6 +1,7 @@
 package storytelling
 import (
 	"evening_detective_server/internal/modules/cleaner"
 	"testing"
 	"github.com/stretchr/testify/assert"
@@ -49,6 +50,50 @@ func Test_story_GetStory(t *testing.T) {
 				},
 			},
 		},
 		{
 			name: "Получение точки проверка регистра",
 			scenario: &Story{
 				Places: []*Place{
 					{
 						Code: "Ы-1",
 						Name: "Название точки",
 						Text: "Текст точки.",
 					},
 				},
 			},
 			codes: []string{"ы1"},
 			want: &Story{
 				Places: []*Place{
 					{
 						Code: "Ы-1",
 						Name: "Название точки",
 						Text: "Текст точки.",
 					},
 				},
 			},
 		},
 		{
 			name: "Получение точки проверка очистки ссылок",
 			scenario: &Story{
 				Places: []*Place{
 					{
 						Code: "Ы-1",
 						Name: "Название точки",
 						Text: "Текст точки.([Ы-2])",
 					},
 				},
 			},
 			codes: []string{"Ы-1"},
 			want: &Story{
 				Places: []*Place{
 					{
 						Code: "Ы-1",
 						Name: "Название точки",
 						Text: "Текст точки.",
 					},
 				},
 			},
 		},
 		{
 			name: "Получение 2 точек",
 			scenario: &Story{
@@ -709,7 +754,7 @@ func Test_story_GetStory(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got := NewStory().GetStory(tt.scenario, tt.codes)
+			got := NewStory(cleaner.NewCleaner()).GetStory(tt.scenario, tt.codes)
 			assert.Equal(t, got, tt.want)
 		})
 	}
@@ -0,0 +1,7 @@
 package string_tools
 // IStringTools — утилиты работы со строками.
 type IStringTools interface {
 	// Transliterate выполняет транслитерацию русского текста в латиницу.
 	Transliterate(text string) string
 }
@@ -44,9 +44,16 @@ var (
 	)
 )
 type stringTools struct{}
 // NewStringTools создаёт реализацию IStringTools.
 func NewStringTools() IStringTools {
 	return &stringTools{}
 }
 // Transliterate выполняет транслитерацию русского текста в латиницу,
 // заменяет пробелы на _, удаляет все остальные символы, кроме цифр (знаки препинания и т.д.)
-func Transliterate(text string) string {
+func (s *stringTools) Transliterate(text string) string {
 	// Приводим к нижнему регистру и транслитерируем
 	result := replacer.Replace(strings.ToLower(text))
@@ -0,0 +1,130 @@
 package actions_repo
 import (
 	"context"
 	"errors"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 var (
 	ErrActionsNotFound = errors.New("Ход не найден")
 )
 type ActionsRepo struct {
 	pool *pgxpool.Pool
 }
 func NewActionsRepo(pool *pgxpool.Pool) *ActionsRepo {
 	return &ActionsRepo{
 		pool: pool,
 	}
 }
 func (r *ActionsRepo) AddAction(ctx context.Context, teamId int, code string) (int, error) {
 	id := 0
 	err := r.pool.QueryRow(
 		ctx,
 		`INSERT INTO actions (code, team_id)
 		VALUES ($1, $2)
 		RETURNING id`,
 		code,
 		teamId,
 	).Scan(&id)
 	if err != nil {
 		return 0, err
 	}
 	return id, nil
 }
 func (r *ActionsRepo) GetActionsByTeamID(ctx context.Context, teamId int) ([]string, error) {
 	rows, err := r.pool.Query(
 		ctx,
 		`SELECT 
 			code
 		FROM actions
 		WHERE team_id = $1
 		ORDER BY created_at ASC`,
 		teamId,
 	)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
 	var codes []string
 	for rows.Next() {
 		code := ""
 		err := rows.Scan(
 			&code,
 		)
 		if err != nil {
 			return nil, err
 		}
 		codes = append(codes, code)
 	}
 	if err := rows.Err(); err != nil {
 		return nil, err
 	}
 	return codes, nil
 }
 func (r *ActionsRepo) GetActionsCountByTeamIDs(ctx context.Context, teamIds []int) (map[int]int, error) {
 	rows, err := r.pool.Query(
 		ctx,
 		`SELECT 
 			team_id, 
 			count(*)
 		FROM actions
 		WHERE team_id = ANY($1)
 		GROUP BY team_id`,
 		teamIds,
 	)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
 	res := make(map[int]int, len(teamIds))
 	for rows.Next() {
 		id := 0
 		count := 0
 		err := rows.Scan(
 			&id,
 			&count,
 		)
 		if err != nil {
 			return nil, err
 		}
 		res[id] = count
 	}
 	if err := rows.Err(); err != nil {
 		return nil, err
 	}
 	return res, nil
 }
 func (r *ActionsRepo) DeleteLastActionByTeamId(ctx context.Context, teamId int) error {
 	tag, err := r.pool.Exec(
 		ctx,
 		`DELETE FROM actions
 		WHERE id IN (
 			SELECT id 
 			FROM actions 
 			WHERE team_id = $1
 			ORDER BY created_at DESC 
 			LIMIT 1
 		)`,
 		teamId,
 	)
 	if err != nil {
 		return err
 	}
 	if tag.RowsAffected() == 0 {
 		return ErrActionsNotFound
 	}
 	return nil
 }
@@ -0,0 +1,7 @@
 package repos
 type Application struct {
 	Name   string
 	Image  string
 	TeamId int
 }
@@ -0,0 +1,135 @@
 package applications_repo
 import (
 	"context"
 	"errors"
 	"evening_detective_server/internal/repos"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 var (
 	ErrApplicationNotFound = errors.New("Улика не найдена")
 )
 type ApplicationsRepo struct {
 	pool *pgxpool.Pool
 }
 func NewApplicationsRepo(pool *pgxpool.Pool) *ApplicationsRepo {
 	return &ApplicationsRepo{
 		pool: pool,
 	}
 }
 func (r *ApplicationsRepo) AddApplication(
 	ctx context.Context,
 	teamId int,
 	name string,
 	image string,
 ) (int, error) {
 	id := 0
 	err := r.pool.QueryRow(
 		ctx,
 		`INSERT INTO applications (name, image, team_id)
 		VALUES ($1, $2, $3)
 		RETURNING id`,
 		name,
 		image,
 		teamId,
 	).Scan(&id)
 	if err != nil {
 		return 0, err
 	}
 	return id, nil
 }
 func (r *ApplicationsRepo) GetApplicationsByTeamIDsAndState(
 	ctx context.Context,
 	teamIds []int,
 	state string,
 ) (map[int][]*repos.Application, error) {
 	rows, err := r.pool.Query(
 		ctx,
 		`SELECT 
 			name,
 			image,
 			team_id
 		FROM applications
 		WHERE team_id = ANY($1) and status = $2`,
 		teamIds,
 		state,
 	)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
 	res := make(map[int][]*repos.Application, len(teamIds))
 	for rows.Next() {
 		application := &repos.Application{}
 		err := rows.Scan(
 			&application.Name,
 			&application.Image,
 			&application.TeamId,
 		)
 		if err != nil {
 			return nil, err
 		}
 		res[application.TeamId] = append(res[application.TeamId], application)
 	}
 	if err := rows.Err(); err != nil {
 		return nil, err
 	}
 	return res, nil
 }
 func (r *ApplicationsRepo) UpdateApplicationStatus(
 	ctx context.Context,
 	teamId int,
 	name string,
 	status string,
 ) error {
 	tag, err := r.pool.Exec(
 		ctx,
 		`UPDATE applications
 		SET 
 			status = $1
 		WHERE team_id = $2 and name = $3`,
 		status,
 		teamId,
 		name,
 	)
 	if err != nil {
 		return err
 	}
 	if tag.RowsAffected() == 0 {
 		return ErrApplicationNotFound
 	}
 	return nil
 }
 func (r *ApplicationsRepo) DeleteApplicationByTeamIdAndName(ctx context.Context, teamId int, name string) error {
 	tag, err := r.pool.Exec(
 		ctx,
 		`DELETE FROM applications
 		WHERE id IN (
 			SELECT id 
 			FROM applications 
 			WHERE team_id = $1 and name = $2
 			ORDER BY created_at DESC 
 			LIMIT 1
 		)`,
 		teamId,
 		name,
 	)
 	if err != nil {
 		return err
 	}
 	if tag.RowsAffected() == 0 {
 		return ErrApplicationNotFound
 	}
 	return nil
 }
@@ -13,4 +13,6 @@ type Game struct {
 	ScenarioId  int
 	Scenario    *Scenario
 	Teams       []*Team
 	StartedAt   *time.Time
 	EndedAt     *time.Time
 }
@@ -62,7 +62,9 @@ func (r *GamesRepo) GetGameByID(
 			games.description, 
 			games.start_at,
 			games.status,
-			games.scenario_id
+			games.scenario_id,
 			games.started_at,
 			games.ended_at
 		FROM games
 		WHERE id = $1`,
 		id,
@@ -74,6 +76,8 @@ func (r *GamesRepo) GetGameByID(
 		&game.StartAt,
 		&game.Status,
 		&game.ScenarioId,
 		&game.StartedAt,
 		&game.EndedAt,
 	)
 	if err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
@@ -177,3 +181,102 @@ func (r *GamesRepo) UpdateGame(
 	}
 	return nil
 }
 func (r *GamesRepo) StartGame(ctx context.Context, id int) error {
 	tag, err := r.pool.Exec(
 		ctx,
 		`UPDATE games
 		SET 
 			status = 'run',
 			started_at = NOW(),
 			updated_at = NOW()
 		WHERE id = $1`,
 		id,
 	)
 	if err != nil {
 		return err
 	}
 	if tag.RowsAffected() == 0 {
 		return ErrGameNotFound
 	}
 	return nil
 }
 func (r *GamesRepo) PauseGame(ctx context.Context, id int) error {
 	tag, err := r.pool.Exec(
 		ctx,
 		`UPDATE games
 		SET 
 			status = 'pause',
 			updated_at = NOW()
 		WHERE id = $1`,
 		id,
 	)
 	if err != nil {
 		return err
 	}
 	if tag.RowsAffected() == 0 {
 		return ErrGameNotFound
 	}
 	return nil
 }
 func (r *GamesRepo) PlayGame(ctx context.Context, id int) error {
 	tag, err := r.pool.Exec(
 		ctx,
 		`UPDATE games
 		SET 
 			status = 'run',
 			updated_at = NOW()
 		WHERE id = $1`,
 		id,
 	)
 	if err != nil {
 		return err
 	}
 	if tag.RowsAffected() == 0 {
 		return ErrGameNotFound
 	}
 	return nil
 }
 func (r *GamesRepo) FinishGame(ctx context.Context, id int) error {
 	tag, err := r.pool.Exec(
 		ctx,
 		`UPDATE games
 		SET 
 			status = 'finish',
 			ended_at = NOW(),
 			updated_at = NOW()
 		WHERE id = $1`,
 		id,
 	)
 	if err != nil {
 		return err
 	}
 	if tag.RowsAffected() == 0 {
 		return ErrGameNotFound
 	}
 	return nil
 }
 func (r *GamesRepo) ResetGame(ctx context.Context, id int) error {
 	tag, err := r.pool.Exec(
 		ctx,
 		`UPDATE games
 		SET 
 			status = 'draft',
 			started_at = DEFAULT,
 			ended_at = DEFAULT,
 			updated_at = NOW()
 		WHERE id = $1`,
 		id,
 	)
 	if err != nil {
 		return err
 	}
 	if tag.RowsAffected() == 0 {
 		return ErrGameNotFound
 	}
 	return nil
 }
@@ -75,17 +75,17 @@ func (r *ScenariosRepo) GetScenariosByAuthorID(
 	var scenarios []*repos.Scenario
 	for rows.Next() {
-		scenario := &repos.Scenario{
+		scenario := &repos.Scenario{}
-			Author: &repos.User{},
+		var authorID *int
-		}
+		var authorUsername *string
 		err := rows.Scan(
 			&scenario.ID,
 			&scenario.Name,
 			&scenario.Description,
 			&scenario.Image,
 			&scenario.Scenario,
-			&scenario.Author.ID,
+			&authorID,
-			&scenario.Author.Username,
+			&authorUsername,
 			&scenario.Status,
 			&scenario.UpdatedAt,
 			&scenario.CreatedAt,
@@ -94,6 +94,9 @@ func (r *ScenariosRepo) GetScenariosByAuthorID(
 		if err != nil {
 			return nil, err
 		}
 		if authorID != nil && authorUsername != nil {
 			scenario.Author = &repos.User{ID: *authorID, Username: *authorUsername}
 		}
 		scenarios = append(scenarios, scenario)
 	}
 	if err := rows.Err(); err != nil {
@@ -134,17 +137,17 @@ func (r *ScenariosRepo) GetScenariosByStatus(
 	var scenarios []*repos.Scenario
 	for rows.Next() {
-		scenario := &repos.Scenario{
+		scenario := &repos.Scenario{}
-			Author: &repos.User{},
+		var authorID *int
-		}
+		var authorUsername *string
 		err := rows.Scan(
 			&scenario.ID,
 			&scenario.Name,
 			&scenario.Description,
 			&scenario.Image,
 			&scenario.Scenario,
-			&scenario.Author.ID,
+			&authorID,
-			&scenario.Author.Username,
+			&authorUsername,
 			&scenario.Status,
 			&scenario.UpdatedAt,
 			&scenario.CreatedAt,
@@ -153,6 +156,9 @@ func (r *ScenariosRepo) GetScenariosByStatus(
 		if err != nil {
 			return nil, err
 		}
 		if authorID != nil && authorUsername != nil {
 			scenario.Author = &repos.User{ID: *authorID, Username: *authorUsername}
 		}
 		scenarios = append(scenarios, scenario)
 	}
 	if err := rows.Err(); err != nil {
@@ -166,9 +172,9 @@ func (r *ScenariosRepo) GetScenarioByID(
 	ctx context.Context,
 	id int,
 ) (*repos.Scenario, error) {
-	scenario := &repos.Scenario{
+	scenario := &repos.Scenario{}
-		Author: &repos.User{},
+	var authorID *int
-	}
+	var authorUsername *string
 	row := r.pool.QueryRow(
 		ctx,
 		`SELECT 
@@ -195,8 +201,8 @@ func (r *ScenariosRepo) GetScenarioByID(
 		&scenario.Description,
 		&scenario.Image,
 		&scenario.Scenario,
-		&scenario.Author.ID,
+		&authorID,
-		&scenario.Author.Username,
+		&authorUsername,
 		&scenario.Status,
 		&scenario.UpdatedAt,
 		&scenario.CreatedAt,
@@ -210,9 +216,15 @@ func (r *ScenariosRepo) GetScenarioByID(
 		return nil, err
 	}
 	// Автор может отсутствовать (обезличен после удаления аккаунта).
 	if authorID != nil && authorUsername != nil {
 		scenario.Author = &repos.User{ID: *authorID, Username: *authorUsername}
 	}
 	return scenario, nil
 }
 // UpdateScenarioByID меняет основные поля сценария.
 func (r *ScenariosRepo) UpdateScenarioByID(
 	ctx context.Context,
 	id int,
@@ -243,50 +255,61 @@ func (r *ScenariosRepo) UpdateScenarioByID(
 	return nil
 }
 // UpdateScenarioStatusByID меняет статус сценария. allowPublished=true
 // разрешает менять статус опубликованного сценария (только для админа).
 // Возвращает false, если строка не обновлена (например, не-админ пытается
 // снять с публикации опубликованный сценарий). published_at фиксируется
 // только при ПЕРВОЙ публикации: повторная публикация не двигает «момент
 // отчуждения» исключительного права (п. 7.2 Пользовательского соглашения).
 func (r *ScenariosRepo) UpdateScenarioStatusByID(
 	ctx context.Context,
 	id int,
 	status string,
-) error {
+	allowPublished bool,
 ) (bool, error) {
 	tag, err := r.pool.Exec(
 		ctx,
 		`UPDATE scenarios
 		SET 
 			status = $1,
-			published_at = NOW(),
+			published_at = CASE
 				WHEN $1 = 'public' AND published_at IS NULL THEN NOW()
 				ELSE published_at
 			END,
 			updated_at = NOW()
-		WHERE id = $2`,
+		WHERE id = $2 AND ($3 OR status <> 'public')`,
 		status,
 		id,
 		allowPublished,
 	)
 	if err != nil {
-		return err
+		return false, err
 	}
-	if tag.RowsAffected() == 0 {
+	return tag.RowsAffected() > 0, nil
 		return ErrScenarioNotFound
 	}
 	return nil
 }
 // DeleteScenarioByID помечает сценарий удалённым (soft delete).
 // allowPublished=true разрешает удаление опубликованного сценария
 // (только для админа). Возвращает false, если строка не обновлена
 // (например, не-админ пытается удалить опубликованный сценарий).
 func (r *ScenariosRepo) DeleteScenarioByID(
 	ctx context.Context,
 	id int,
-) error {
+	allowPublished bool,
 ) (bool, error) {
 	tag, err := r.pool.Exec(
 		ctx,
 		`UPDATE scenarios
 		SET 
 			is_deleted = TRUE
-		WHERE id = $1`,
+		WHERE id = $1 AND ($2 OR status <> 'public')`,
 		id,
 		allowPublished,
 	)
 	if err != nil {
-		return err
+		return false, err
 	}
-	if tag.RowsAffected() == 0 {
+	return tag.RowsAffected() > 0, nil
 		return ErrScenarioNotFound
 	}
 	return nil
 }
 func (r *ScenariosRepo) GetStoryByScenarioID(
@@ -315,6 +338,7 @@ func (r *ScenariosRepo) GetStoryByScenarioID(
 	return story, nil
 }
 // UpdateStoryByScenarioID обновляет содержимое (историю) сценария.
 func (r *ScenariosRepo) UpdateStoryByScenarioID(
 	ctx context.Context,
 	id int,
@@ -3,5 +3,7 @@ package repos
 type Team struct {
 	ID       int
 	Name     string
 	Status   string
 	Password string
 	GameId   int
 }
@@ -2,11 +2,17 @@ package teams_repo
 import (
 	"context"
 	"errors"
 	"evening_detective_server/internal/repos"
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 var (
 	ErrTeamNotFound = errors.New("Команда не найдена")
 )
 type TeamsRepo struct {
 	pool *pgxpool.Pool
 }
@@ -17,6 +23,37 @@ func NewTeamsRepo(pool *pgxpool.Pool) *TeamsRepo {
 	}
 }
 func (r *TeamsRepo) GetTeamByID(ctx context.Context, id int) (*repos.Team, error) {
 	team := &repos.Team{}
 	row := r.pool.QueryRow(
 		ctx,
 		`SELECT 
 			id, 
 			name, 
 			status,
 			password,
 			game_id
 		FROM teams
 		WHERE id = $1`,
 		id,
 	)
 	err := row.Scan(
 		&team.ID,
 		&team.Name,
 		&team.Status,
 		&team.Password,
 		&team.GameId,
 	)
 	if err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return nil, ErrTeamNotFound
 		}
 		return nil, err
 	}
 	return team, nil
 }
 func (r *TeamsRepo) GetTeamsByGameID(
 	ctx context.Context,
 	gameId int,
@@ -24,20 +61,12 @@ func (r *TeamsRepo) GetTeamsByGameID(
 	rows, err := r.pool.Query(
 		ctx,
 		`SELECT 
-			scenarios.id, 
+			id, 
-			scenarios.name, 
+			name, 
-			scenarios.description, 
+			status,
-			scenarios.image, 
+			password
-			scenarios.scenario, 
+		FROM teams
-			users.id, 
+		WHERE game_id = $1
 			users.username, 
 			scenarios.status, 
 			scenarios.updated_at, 
 			scenarios.created_at, 
 			scenarios.published_at
 		FROM scenarios
 		LEFT JOIN users on scenarios.author_id = users.id
 		WHERE scenarios.author_id = $1 and is_deleted = FALSE
 		ORDER BY created_at DESC`,
 		gameId,
 	)
@@ -52,6 +81,7 @@ func (r *TeamsRepo) GetTeamsByGameID(
 		err := rows.Scan(
 			&team.ID,
 			&team.Name,
 			&team.Status,
 			&team.Password,
 		)
 		if err != nil {
@@ -65,3 +95,63 @@ func (r *TeamsRepo) GetTeamsByGameID(
 	return teams, nil
 }
 func (r *TeamsRepo) AddTeam(
 	ctx context.Context,
 	creatorId int,
 	gameId int,
 	name string,
 	password string,
 ) (int, error) {
 	id := 0
 	err := r.pool.QueryRow(
 		ctx,
 		`INSERT INTO teams (name, creator_id, game_id, password)
 		VALUES ($1, $2, $3, $4)
 		RETURNING id`,
 		name,
 		creatorId,
 		gameId,
 		password,
 	).Scan(&id)
 	if err != nil {
 		return 0, err
 	}
 	return id, nil
 }
 func (r *TeamsRepo) UpdateTeam(ctx context.Context, teamId int, name string) error {
 	tag, err := r.pool.Exec(
 		ctx,
 		`UPDATE teams
 		SET 
 			name = $1
 		WHERE id = $2`,
 		name,
 		teamId,
 	)
 	if err != nil {
 		return err
 	}
 	if tag.RowsAffected() == 0 {
 		return ErrTeamNotFound
 	}
 	return nil
 }
 func (r *TeamsRepo) DeleteTeam(ctx context.Context, teamId int) error {
 	tag, err := r.pool.Exec(
 		ctx,
 		`DELETE FROM teams
 		WHERE id = $1`,
 		teamId,
 	)
 	if err != nil {
 		return err
 	}
 	if tag.RowsAffected() == 0 {
 		return ErrTeamNotFound
 	}
 	return nil
 }
@@ -0,0 +1,18 @@
 package user_agreements_repo
 // AgreementType — типы документов, акцептуемых пользователем.
 const (
 	AgreementTypeTerms   = "terms"   // Пользовательское соглашение
 	AgreementTypePrivacy = "privacy" // Политика конфиденциальности
 )
 // Agreement — фиксируемый факт акцепта документа (ст. 9 152-ФЗ — согласие в
 // форме, позволяющей подтвердить факт его получения). Version должна
 // соответствовать опубликованной редакции документа; при изменении текста
 // документа версия обязана увеличиваться.
 type Agreement struct {
 	AgreementType string
 	Version       string
 	IP            string
 	UserAgent     string
 }
@@ -4,9 +4,11 @@ import (
 	"context"
 	"errors"
 	"evening_detective_server/internal/repos"
 	"evening_detective_server/internal/repos/user_agreements_repo"
 	"fmt"
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgconn"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
@@ -24,21 +26,40 @@ func NewUserRepo(pool *pgxpool.Pool) *UsersRepo {
 	}
 }
-func (s *UsersRepo) AddUser(
+// AddUserWithAgreements создаёт пользователя и фиксирует акцепты документов
 // (user_agreements) в одной транзакции: пользователь либо существует вместе с
 // записями о согласиях, либо не существует вовсе (доказуемое согласие,
 // ст. 9 152-ФЗ). Возвращает id созданного пользователя.
 func (s *UsersRepo) AddUserWithAgreements(
 	ctx context.Context,
 	username string,
 	email string,
 	passwordHash string,
 	roles []string,
-) error {
+	agreements []user_agreements_repo.Agreement,
-	tag, err := s.pool.Exec(
+) (int, error) {
 	// Инвариант «пользователь не существует без записей о согласиях»
 	// держится на том, что акцепты передаются всегда.
 	if len(agreements) == 0 {
 		return 0, errors.New("Не переданы записи об акцепте соглашений")
 	}
 	tx, err := s.pool.Begin(ctx)
 	if err != nil {
 		return 0, err
 	}
 	defer tx.Rollback(ctx) //nolint:errcheck
 	var id int
 	err = tx.QueryRow(
 		ctx,
 		`INSERT INTO users (username, email, password_hash, roles)
 		SELECT $1, $2, $3, $4
 		WHERE NOT EXISTS (
 			SELECT 1 FROM users 
 			WHERE username = $5 OR email = $6
-		)`,
+		)
 		RETURNING id`,
 		username,
 		email,
 		passwordHash,
@@ -46,14 +67,41 @@ func (s *UsersRepo) AddUser(
 		username,
 		email,
-	)
+	).Scan(&id)
 	if err != nil {
-		return err
+		// Ничего не вставлено — занят username или email.
 		if errors.Is(err, pgx.ErrNoRows) {
 			return 0, errors.New("Username или email уже используется")
 		}
-	if tag.RowsAffected() == 0 {
+		// Гонка: между проверкой NOT EXISTS и INSERT другой запрос успел
-		return errors.New("username или email уже используется")
+		// создать пользователя с тем же username/email — нарушение
 		// уникальности. Возвращаем тот же понятный клиенту ответ.
 		var pgErr *pgconn.PgError
 		if errors.As(err, &pgErr) && pgErr.Code == "23505" { // unique_violation
 			return 0, errors.New("Username или email уже используется")
 		}
-	return nil
+		return 0, err
 	}
 	for _, agreement := range agreements {
 		if _, err = tx.Exec(
 			ctx,
 			`INSERT INTO user_agreements (user_id, agreement_type, version, ip, user_agent)
 			VALUES ($1, $2, $3, $4, $5)`,
 			id,
 			agreement.AgreementType,
 			agreement.Version,
 			agreement.IP,
 			agreement.UserAgent,
 		); err != nil {
 			return 0, err
 		}
 	}
 	if err = tx.Commit(ctx); err != nil {
 		return 0, err
 	}
 	return id, nil
 }
 func (s *UsersRepo) UpdateUserPassword(
@@ -207,3 +255,62 @@ func (s *UsersRepo) DeleteUserRole(
 	)
 	return err
 }
 // DeleteUser удаляет учётную запись и персональные данные пользователя
 // (ст. 21 152-ФЗ — уничтожение ПДн при удалении аккаунта). Выполняется в одной
 // транзакции. Публичный контент пользователя (сценарии, команды) сохраняется:
 // FK-ограничения с ON DELETE SET NULL (миграция
 // 20260818232725_keep_content_on_user_delete.sql) обнуляют привязку к автору —
 // контент остаётся в обезличенном виде.
 func (s *UsersRepo) DeleteUser(
 	ctx context.Context,
 	userId int,
 ) error {
 	tx, err := s.pool.Begin(ctx)
 	if err != nil {
 		return err
 	}
 	defer tx.Rollback(ctx) //nolint:errcheck
 	// Refresh-токены (FK CASCADE, удаляем явно для предсказуемости).
 	if _, err = tx.Exec(
 		ctx,
 		`DELETE FROM refresh_tokens WHERE user_id = $1`,
 		userId,
 	); err != nil {
 		return err
 	}
 	// Зафиксированные акцепты соглашений НЕ удаляются: ст. 9 ч. 4 152-ФЗ
 	// возлагает на оператора бремя доказывания получения согласия, поэтому
 	// факт акцепта (документ, версия, время) сохраняется в обезличенном виде:
 	// ссылка на пользователя и персональные данные внутри записи (ip,
 	// user_agent) обнуляются. FK ON DELETE SET NULL (миграция
 	// 20260818231943_create_user_agreements_table.sql) гарантирует, что при
 	// удалении users строки акцептов остаются с user_id = NULL.
 	if _, err = tx.Exec(
 		ctx,
 		`UPDATE user_agreements
 		SET user_id = NULL, ip = NULL, user_agent = NULL
 		WHERE user_id = $1`,
 		userId,
 	); err != nil {
 		return err
 	}
 	// Пользователь. Связанные сценарии (author_id) и команды (creator_id)
 	// обнуляются автоматически через ON DELETE SET NULL.
 	tag, err := tx.Exec(
 		ctx,
 		`DELETE FROM users WHERE id = $1`,
 		userId,
 	)
 	if err != nil {
 		return err
 	}
 	if tag.RowsAffected() == 0 {
 		return ErrUserNotFound
 	}
 	return tx.Commit(ctx)
 }
@@ -8,13 +8,16 @@ import (
 type FileService struct {
 	fileStorage file_storage.IFileStorage
 	stringTools string_tools.IStringTools
 }
 func NewFileService(
 	fileStorage file_storage.IFileStorage,
 	stringTools string_tools.IStringTools,
 ) *FileService {
 	return &FileService{
 		fileStorage: fileStorage,
 		stringTools: stringTools,
 	}
 }
@@ -22,7 +25,7 @@ func (s *FileService) UploadFile(
 	ctx context.Context,
 	file *file_storage.File,
 ) (string, error) {
-	file.Name = string_tools.Transliterate(file.Name)
+	file.Name = s.stringTools.Transliterate(file.Name)
 	if err := s.fileStorage.Put(ctx, file); err != nil {
 		return "", err
 	}
@@ -0,0 +1,6 @@
 package game_service
 type Application struct {
 	Name  string
 	Image string
 }
@@ -0,0 +1,21 @@
 package game_service
 import (
 	"evening_detective_server/internal/modules/storytelling"
 	"evening_detective_server/internal/repos"
 )
 func mapApplications(o []*repos.Application) []*storytelling.Application {
 	res := make([]*storytelling.Application, 0, len(o))
 	for _, item := range o {
 		res = append(res, mapApplication(item))
 	}
 	return res
 }
 func mapApplication(o *repos.Application) *storytelling.Application {
 	return &storytelling.Application{
 		Name:  o.Name,
 		Image: o.Image,
 	}
 }
@@ -13,4 +13,6 @@ type Game struct {
 	Status      string
 	Scenario    *scenarios_service.Scenario
 	Teams       []*Team
 	StartedAt   *time.Time
 	EndedAt     *time.Time
 }
@@ -17,6 +17,8 @@ func mapGame(
 		Status:      o.Status,
 		Scenario:    scenarios_service.MapScenarioLight(o.Scenario, domain),
 		Teams:       mapTeams(o.Teams),
 		StartedAt:   o.StartedAt,
 		EndedAt:     o.EndedAt,
 	}
 }
@@ -2,9 +2,15 @@ package game_service
 import (
 	"context"
 	"evening_detective_server/internal/modules/cleaner"
 	"evening_detective_server/internal/modules/password_generator"
 	"evening_detective_server/internal/modules/storytelling"
 	"evening_detective_server/internal/repos/actions_repo"
 	"evening_detective_server/internal/repos/applications_repo"
 	"evening_detective_server/internal/repos/games_repo"
 	"evening_detective_server/internal/repos/scenarios_repo"
 	"evening_detective_server/internal/repos/teams_repo"
 	"evening_detective_server/internal/services/scenarios_service"
 	"time"
 )
@@ -12,20 +18,38 @@ type GameService struct {
 	gamesRepo         *games_repo.GamesRepo
 	teamsRepo         *teams_repo.TeamsRepo
 	scenariosRepo     *scenarios_repo.ScenariosRepo
 	scenarioService   *scenarios_service.ScenarioService
 	domain            string
 	passwordGenerator password_generator.IPasswordGenerator
 	storyteller       storytelling.IStory
 	actionsRepo       *actions_repo.ActionsRepo
 	applicationsRepo  *applications_repo.ApplicationsRepo
 	cleaner           cleaner.ICleaner
 }
 func NewGameService(
 	gamesRepo *games_repo.GamesRepo,
 	teamsRepo *teams_repo.TeamsRepo,
 	scenariosRepo *scenarios_repo.ScenariosRepo,
 	scenarioService *scenarios_service.ScenarioService,
 	domain string,
 	passwordGenerator password_generator.IPasswordGenerator,
 	storyteller storytelling.IStory,
 	actionsRepo *actions_repo.ActionsRepo,
 	applicationsRepo *applications_repo.ApplicationsRepo,
 	cleaner cleaner.ICleaner,
 ) *GameService {
 	return &GameService{
 		gamesRepo:         gamesRepo,
 		teamsRepo:         teamsRepo,
 		scenariosRepo:     scenariosRepo,
 		scenarioService:   scenarioService,
 		domain:            domain,
 		passwordGenerator: passwordGenerator,
 		storyteller:       storyteller,
 		actionsRepo:       actionsRepo,
 		applicationsRepo:  applicationsRepo,
 		cleaner:           cleaner,
 	}
 }
@@ -43,7 +67,16 @@ func (s *GameService) AddGame(
 	return id, nil
 }
-func (s *GameService) GetGame(
+func (s *GameService) GetGame(ctx context.Context, id int) (*Game, error) {
 	game, err := s.gamesRepo.GetGameByID(ctx, id)
 	if err != nil {
 		return nil, err
 	}
 	res := mapGame(game, s.domain)
 	return res, nil
 }
 func (s *GameService) GetFullGame(
 	ctx context.Context,
 	id int,
 ) (*Game, error) {
@@ -61,7 +94,30 @@ func (s *GameService) GetGame(
 		return nil, err
 	}
 	game.Teams = teams
-	return mapGame(game, s.domain), nil
+
 	res := mapGame(game, s.domain)
 	teamIds := make([]int, 0, len(game.Teams))
 	for _, team := range game.Teams {
 		teamIds = append(teamIds, team.ID)
 	}
 	actionsCountByTeamIDs, err := s.actionsRepo.GetActionsCountByTeamIDs(ctx, teamIds)
 	if err != nil {
 		return nil, err
 	}
 	needApplicationsByTeamIDs, err := s.applicationsRepo.GetApplicationsByTeamIDsAndState(ctx, teamIds, "need")
 	if err != nil {
 		return nil, err
 	}
 	for _, team := range res.Teams {
 		team.ActionsCount = actionsCountByTeamIDs[team.ID]
 		team.Applications = mapApplications(needApplicationsByTeamIDs[team.ID])
 	}
 	return res, nil
 }
 func (s *GameService) DeleteGame(
@@ -91,3 +147,161 @@ func (s *GameService) UpdateGame(
 ) error {
 	return s.gamesRepo.UpdateGame(ctx, id, name, description, startAt, scenarioId)
 }
 func (s *GameService) StartGame(ctx context.Context, id int) error {
 	return s.gamesRepo.StartGame(ctx, id)
 }
 func (s *GameService) PauseGame(ctx context.Context, id int) error {
 	return s.gamesRepo.PauseGame(ctx, id)
 }
 func (s *GameService) PlayGame(ctx context.Context, id int) error {
 	return s.gamesRepo.PlayGame(ctx, id)
 }
 func (s *GameService) FinishGame(ctx context.Context, id int) error {
 	return s.gamesRepo.FinishGame(ctx, id)
 }
 func (s *GameService) ResetGame(ctx context.Context, id int) error {
 	return s.gamesRepo.ResetGame(ctx, id)
 }
 func (s *GameService) AddTeam(
 	ctx context.Context,
 	creatorId int,
 	gameId int,
 	name string,
 ) (*Team, error) {
 	password, err := s.passwordGenerator.Generate()
 	if err != nil {
 		return nil, err
 	}
 	id, err := s.teamsRepo.AddTeam(ctx, creatorId, gameId, name, password)
 	if err != nil {
 		return nil, err
 	}
 	return &Team{
 		ID:       id,
 		Password: password,
 	}, nil
 }
 func (s *GameService) UpdateTeam(ctx context.Context, teamId int, name string) error {
 	return s.teamsRepo.UpdateTeam(ctx, teamId, name)
 }
 func (s *GameService) DeleteTeam(ctx context.Context, teamId int) error {
 	return s.teamsRepo.DeleteTeam(ctx, teamId)
 }
 func (s *GameService) GiveTeamApplications(ctx context.Context, teamId int, name string) error {
 	return s.applicationsRepo.UpdateApplicationStatus(ctx, teamId, name, "done")
 }
 func (s *GameService) GetTeamActions(ctx context.Context, teamId int, password string) (*storytelling.Story, *Game, error) {
 	team, err := s.teamsRepo.GetTeamByID(ctx, teamId)
 	if err != nil {
 		return nil, nil, err
 	}
 	if team.Password != password {
 		return nil, nil, teams_repo.ErrTeamNotFound
 	}
 	game, err := s.gamesRepo.GetGameByID(ctx, team.GameId)
 	if err != nil {
 		return nil, nil, err
 	}
 	actions, err := s.actionsRepo.GetActionsByTeamID(ctx, teamId)
 	if err != nil {
 		return nil, nil, err
 	}
 	scenario, err := s.scenarioService.GetFullScenarioByID(ctx, game.ScenarioId)
 	if err != nil {
 		return nil, nil, err
 	}
 	return s.storyteller.GetStory(scenario.Story, actions), mapGame(game, s.domain), nil
 }
 func (s *GameService) AddTeamAction(ctx context.Context, teamId int, password string, actionCode string) error {
 	team, err := s.teamsRepo.GetTeamByID(ctx, teamId)
 	if err != nil {
 		return err
 	}
 	if team.Password != password {
 		return teams_repo.ErrTeamNotFound
 	}
 	_, err = s.actionsRepo.AddAction(ctx, teamId, actionCode)
 	if err != nil {
 		return err
 	}
 	game, err := s.gamesRepo.GetGameByID(ctx, team.GameId)
 	if err != nil {
 		return err
 	}
 	actions, err := s.actionsRepo.GetActionsByTeamID(ctx, teamId)
 	if err != nil {
 		return err
 	}
 	scenario, err := s.scenarioService.GetFullScenarioByID(ctx, game.ScenarioId)
 	if err != nil {
 		return err
 	}
 	teamStory := s.storyteller.GetStory(scenario.Story, actions)
 	lastPlace := teamStory.Places[len(teamStory.Places)-1]
 	for _, application := range lastPlace.Applications {
 		_, err := s.applicationsRepo.AddApplication(ctx, teamId, s.cleaner.ClearText(application.Name), application.Image)
 		if err != nil {
 			return err
 		}
 	}
 	return nil
 }
 func (s *GameService) DeleteLastTeamAction(ctx context.Context, teamId int) error {
 	team, err := s.teamsRepo.GetTeamByID(ctx, teamId)
 	if err != nil {
 		return err
 	}
 	game, err := s.gamesRepo.GetGameByID(ctx, team.GameId)
 	if err != nil {
 		return err
 	}
 	actions, err := s.actionsRepo.GetActionsByTeamID(ctx, teamId)
 	if err != nil {
 		return err
 	}
 	scenario, err := s.scenarioService.GetFullScenarioByID(ctx, game.ScenarioId)
 	if err != nil {
 		return err
 	}
 	teamStory := s.storyteller.GetStory(scenario.Story, actions)
 	lastPlace := teamStory.Places[len(teamStory.Places)-1]
 	for _, application := range lastPlace.Applications {
 		if err := s.applicationsRepo.DeleteApplicationByTeamIdAndName(ctx, teamId, application.Name); err != nil {
 			return err
 		}
 	}
 	return s.actionsRepo.DeleteLastActionByTeamId(ctx, teamId)
 }
@@ -1,7 +1,12 @@
 package game_service
 import "evening_detective_server/internal/modules/storytelling"
 type Team struct {
 	ID           int
 	Name         string
 	Status       string
 	Password     string
 	ActionsCount int
 	Applications []*storytelling.Application
 }
@@ -8,6 +8,7 @@ func mapTeam(
 	return &Team{
 		ID:       o.ID,
 		Name:     o.Name,
 		Status:   o.Status,
 		Password: o.Password,
 	}
 }
@@ -2,23 +2,54 @@ package scenarios_service
 import (
 	"context"
 	"crypto/rand"
 	"encoding/hex"
 	"errors"
 	"evening_detective_server/internal/modules/cleaner"
 	"evening_detective_server/internal/modules/file_storage"
 	"evening_detective_server/internal/modules/scenario_archive"
 	"evening_detective_server/internal/modules/storytelling"
 	"evening_detective_server/internal/repos"
 	"evening_detective_server/internal/repos/scenarios_repo"
 	"fmt"
 	"path/filepath"
 	"strings"
 )
 // scenariosRepository — граница доступа к данным сценариев, реализуемая
 // *scenarios_repo.ScenariosRepo (интерфейс — для тестов без БД).
 type scenariosRepository interface {
 	AddScenario(ctx context.Context, name string, authorId int) (int, error)
 	GetScenariosByAuthorID(ctx context.Context, authorId int) ([]*repos.Scenario, error)
 	GetScenariosByStatus(ctx context.Context, status string) ([]*repos.Scenario, error)
 	GetScenarioByID(ctx context.Context, id int) (*repos.Scenario, error)
 	UpdateScenarioByID(ctx context.Context, id int, name string, description string, image string) error
 	UpdateScenarioStatusByID(ctx context.Context, id int, status string, allowPublished bool) (bool, error)
 	DeleteScenarioByID(ctx context.Context, id int, allowPublished bool) (bool, error)
 	GetStoryByScenarioID(ctx context.Context, id int) (string, error)
 	UpdateStoryByScenarioID(ctx context.Context, id int, story string) error
 }
 type ScenarioService struct {
-	scenariosRepo *scenarios_repo.ScenariosRepo
+	scenariosRepo   scenariosRepository
 	cleaner         cleaner.ICleaner
 	fileStorage     file_storage.IFileStorage
 	scenarioArchive scenario_archive.IScenarioArchive
 	domain          string
 }
 func NewScenarioService(
-	scenariosRepo *scenarios_repo.ScenariosRepo,
+	scenariosRepo scenariosRepository,
 	cleaner cleaner.ICleaner,
 	domain string,
 	fileStorage file_storage.IFileStorage,
 	scenarioArchive scenario_archive.IScenarioArchive,
 ) *ScenarioService {
 	return &ScenarioService{
 		scenariosRepo:   scenariosRepo,
 		cleaner:         cleaner,
 		fileStorage:     fileStorage,
 		scenarioArchive: scenarioArchive,
 		domain:          domain,
 	}
 }
@@ -84,30 +115,111 @@ func (s *ScenarioService) UpdateScenarioByID(
 	name string,
 	description string,
 	image string,
 	actorId int,
 	isAdmin bool,
 ) error {
 	if _, err := s.getScenarioForChange(ctx, id, actorId, isAdmin); err != nil {
 		return err
 	}
 	return s.scenariosRepo.UpdateScenarioByID(ctx, id, name, description, image)
 }
 // ErrScenarioPublished — опубликованный сценарий нельзя снять с публикации
 // или удалить: при публикации исключительное право отчуждается Оператору
 // (п. 7.2 Пользовательского соглашения, ст. 1234 ГК РФ), а право на отзыв
 // действует только до обнародования (ст. 1269 ГК РФ).
 var ErrScenarioPublished = errors.New("Опубликованный сценарий нельзя снять с публикации или удалить: исключительное право отчуждено Оператору")
 // ErrScenarioNotOwner — сценарий принадлежит другому пользователю.
 var ErrScenarioNotOwner = errors.New("Сценарий принадлежит другому пользователю")
 // getScenarioForChange проверяет права актора на изменение сценария:
 // не-админ должен быть автором сценария, сценарий не должен быть удалён.
 // Возвращает сценарий, чтобы вызывающий код не делал повторное чтение.
 func (s *ScenarioService) getScenarioForChange(
 	ctx context.Context,
 	id int,
 	actorId int,
 	isAdmin bool,
 ) (*repos.Scenario, error) {
 	scenario, err := s.scenariosRepo.GetScenarioByID(ctx, id)
 	if err != nil {
 		return nil, err
 	}
 	if scenario.IsDeleted {
 		return nil, scenarios_repo.ErrScenarioNotFound
 	}
 	if isAdmin {
 		return scenario, nil
 	}
 	if scenario.Author == nil || scenario.Author.ID != actorId {
 		return nil, ErrScenarioNotOwner
 	}
 	return scenario, nil
 }
 func (s *ScenarioService) UpdateScenarioStatusByID(
 	ctx context.Context,
 	id int,
 	status string,
 	actorId int,
 	isAdmin bool,
 ) error {
-	return s.scenariosRepo.UpdateScenarioStatusByID(ctx, id, status)
+	scenario, err := s.getScenarioForChange(ctx, id, actorId, isAdmin)
 	if err != nil {
 		return err
 	}
 	if !isAdmin && scenario.Status == "public" {
 		// Повторная публикация уже опубликованного — идемпотентный успех
 		// (published_at не двигается: CASE WHEN published_at IS NULL).
 		if status == "public" {
 			return nil
 		}
 		return ErrScenarioPublished
 	}
 	// Guard в SQL защищает от гонки «чтение статуса → запись»: не-админ не
 	// сможет перевести в draft сценарий, опубликованный между чтением и UPDATE.
 	updated, err := s.scenariosRepo.UpdateScenarioStatusByID(ctx, id, status, isAdmin)
 	if err != nil {
 		return err
 	}
 	if !updated {
 		return ErrScenarioPublished
 	}
 	return nil
 }
 func (s *ScenarioService) DeleteScenarioByID(
 	ctx context.Context,
 	id int,
 	actorId int,
 	isAdmin bool,
 ) error {
-	return s.scenariosRepo.DeleteScenarioByID(ctx, id)
+	if _, err := s.getScenarioForChange(ctx, id, actorId, isAdmin); err != nil {
 		return err
 	}
 	// Guard в SQL защищает от гонки «чтение статуса → запись»: не-админ не
 	// сможет удалить сценарий, опубликованный между чтением и UPDATE.
 	updated, err := s.scenariosRepo.DeleteScenarioByID(ctx, id, isAdmin)
 	if err != nil {
 		return err
 	}
 	if !updated {
 		return ErrScenarioPublished
 	}
 	return nil
 }
 func (s *ScenarioService) AddScenarioPlace(
 	ctx context.Context,
 	id int,
 	place *storytelling.Place,
 	actorId int,
 	isAdmin bool,
 ) error {
 	if _, err := s.getScenarioForChange(ctx, id, actorId, isAdmin); err != nil {
 		return err
 	}
 	story, err := s.getStory(ctx, id)
 	if err != nil {
 		return err
@@ -124,7 +236,12 @@ func (s *ScenarioService) UpdateScenarioPlace(
 	id int,
 	code string,
 	place *storytelling.Place,
 	actorId int,
 	isAdmin bool,
 ) error {
 	if _, err := s.getScenarioForChange(ctx, id, actorId, isAdmin); err != nil {
 		return err
 	}
 	story, err := s.getStory(ctx, id)
 	if err != nil {
 		return err
@@ -142,7 +259,12 @@ func (s *ScenarioService) DeleteScenarioPlace(
 	ctx context.Context,
 	id int,
 	code string,
 	actorId int,
 	isAdmin bool,
 ) error {
 	if _, err := s.getScenarioForChange(ctx, id, actorId, isAdmin); err != nil {
 		return err
 	}
 	story, err := s.getStory(ctx, id)
 	if err != nil {
 		return err
@@ -164,20 +286,170 @@ func (s *ScenarioService) getStory(ctx context.Context, id int) (*storytelling.S
 	return mapStory(storyString, s.domain)
 }
-func (s *ScenarioService) updateStory(ctx context.Context, id int, story *storytelling.Story) error {
+// DownloadArchive собирает ZIP-архив сценария
-	mapCodes := map[string]struct{}{}
+func (s *ScenarioService) DownloadArchive(
-	for _, place := range story.Places {
+	ctx context.Context,
-		mapCodes[place.Code] = struct{}{}
+	id int,
-		place.Image = strings.TrimPrefix(place.Image, s.domain)
+	actorId int,
 	isAdmin bool,
 ) ([]byte, string, error) {
 	scenario, err := s.getScenarioForChange(ctx, id, actorId, isAdmin)
 	if err != nil {
 		return nil, "", err
 	}
-	if len(mapCodes) != len(story.Places) {
+	data, err := s.scenarioArchive.Pack(
-		return errors.New("Такой код точки уже существует")
+		ctx,
 		scenario,
 		s.domain,
 		func(ctx context.Context, name string) ([]byte, error) {
 			file, err := s.fileStorage.Get(ctx, name)
 			if err != nil {
 				return nil, err
 			}
 			return file.Data, nil
 		},
 	)
 	if err != nil {
 		return nil, "", err
 	}
 	return data, scenario.Name, nil
 }
 // UploadArchive импортирует сценарий из ZIP-архива: изображения сохраняются
 // под новыми случайными именами (не перетирают чужие файлы), ссылки
 // переписываются. Новый сценарий всегда draft — статус из архива игнорируется.
 func (s *ScenarioService) UploadArchive(
 	ctx context.Context,
 	data []byte,
 	authorId int,
 ) (int, error) {
 	bundle, err := s.scenarioArchive.Unpack(data)
 	if err != nil {
 		return 0, err
 	}
 	scenario := bundle.Scenario
 	// При ошибке удаляем загруженные файлы (best-effort) — без orphan-объектов.
 	uploaded := map[string]string{}
 	ok := false
 	defer func() {
 		if ok {
 			return
 		}
 		for _, name := range uploaded {
 			_ = s.fileStorage.Delete(ctx, name)
 		}
 	}()
 	rewrite := func(ref string) (string, error) {
 		// Берём только ссылки images/... из архива; остальное — как есть.
 		archiveRef := strings.TrimPrefix(ref, s.domain)
 		if !strings.HasPrefix(archiveRef, "images/") {
 			return ref, nil
 		}
 		if name, exists := uploaded[archiveRef]; exists {
 			return name, nil
 		}
 		content, exists := bundle.Files[archiveRef]
 		if !exists {
 			return "", fmt.Errorf("изображение %q не найдено в архиве", archiveRef)
 		}
 		name, err := newStorageName(archiveRef)
 		if err != nil {
 			return "", err
 		}
 		if err := s.fileStorage.Put(ctx, &file_storage.File{
 			Name: name,
 			Data: content,
 			Mime: s.fileStorage.MimeType(name),
 		}); err != nil {
 			return "", fmt.Errorf("не удалось сохранить изображение %q: %w", archiveRef, err)
 		}
 		uploaded[archiveRef] = name
 		return name, nil
 	}
-	storyString, err := convertStory(story)
+	image, err := rewrite(scenario.Image)
 	if err != nil {
 		return 0, err
 	}
 	for _, place := range scenario.Story.Places {
 		place.Image, err = rewrite(place.Image)
 		if err != nil {
 			return 0, err
 		}
 		for _, application := range place.Applications {
 			application.Image, err = rewrite(application.Image)
 			if err != nil {
 				return 0, err
 			}
 		}
 	}
 	storyJSON, err := normalizeStory(scenario.Story)
 	if err != nil {
 		return 0, err
 	}
 	id, err := s.scenariosRepo.AddScenario(ctx, scenario.Name, authorId)
 	if err != nil {
 		return 0, err
 	}
 	if err := s.scenariosRepo.UpdateScenarioByID(ctx, id, scenario.Name, scenario.Description, image); err != nil {
 		// Зачищаем строку сценария (best-effort), как и файлы.
 		_, _ = s.scenariosRepo.DeleteScenarioByID(ctx, id, true)
 		return 0, err
 	}
 	if err := s.scenariosRepo.UpdateStoryByScenarioID(ctx, id, storyJSON); err != nil {
 		_, _ = s.scenariosRepo.DeleteScenarioByID(ctx, id, true)
 		return 0, err
 	}
 	ok = true
 	return id, nil
 }
 // newStorageName — случайное имя в хранилище (hex + расширение): исключает
 // коллизии с файлами других сценариев в общем бакете.
 func newStorageName(archivePath string) (string, error) {
 	var b [16]byte
 	if _, err := rand.Read(b[:]); err != nil {
 		return "", fmt.Errorf("не удалось сгенерировать имя файла: %w", err)
 	}
 	ext := strings.ToLower(filepath.Ext(archivePath))
 	return hex.EncodeToString(b[:]) + ext, nil
 }
 func (s *ScenarioService) updateStory(ctx context.Context, id int, story *storytelling.Story) error {
 	for _, place := range story.Places {
 		place.Image = strings.TrimPrefix(place.Image, s.domain)
 	}
 	storyString, err := normalizeStory(story)
 	if err != nil {
 		return err
 	}
 	return s.scenariosRepo.UpdateStoryByScenarioID(ctx, id, storyString)
 }
 // normalizeStory проверяет уникальность кодов точек, отбрасывает пустые коды
 // и возвращает JSON истории. Общая для редактирования и импорта.
 func normalizeStory(story *storytelling.Story) (string, error) {
 	codes := map[string]struct{}{}
 	for _, place := range story.Places {
 		codes[place.Code] = struct{}{}
 	}
 	if len(codes) != len(story.Places) {
 		return "", errors.New("Такой код точки уже существует")
 	}
 	cleanPlaces := make([]*storytelling.Place, 0, len(story.Places))
 	for _, place := range story.Places {
 		if place.Code == "" {
 			continue
 		}
 		cleanPlaces = append(cleanPlaces, place)
 	}
 	story.Places = cleanPlaces
 	return convertStory(story)
 }
@@ -0,0 +1,539 @@
 package scenarios_service
 import (
 	"archive/zip"
 	"bytes"
 	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"strings"
 	"sync"
 	"testing"
 	"evening_detective_server/internal/modules/file_storage"
 	"evening_detective_server/internal/modules/scenario_archive"
 	"evening_detective_server/internal/modules/storytelling"
 	"evening_detective_server/internal/repos"
 	"evening_detective_server/internal/repos/scenarios_repo"
 )
 const testDomain = "http://storage.test/api/files/"
 // fakeStorage — in-memory реализация IFileStorage.
 type fakeStorage struct {
 	mu     sync.Mutex
 	files  map[string]*file_storage.File
 	getErr error
 }
 func newFakeStorage() *fakeStorage {
 	return &fakeStorage{files: map[string]*file_storage.File{}}
 }
 func (s *fakeStorage) Put(_ context.Context, f *file_storage.File) error {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	cp := *f
 	cp.Data = append([]byte(nil), f.Data...)
 	s.files[f.Name] = &cp
 	return nil
 }
 func (s *fakeStorage) Get(_ context.Context, name string) (*file_storage.File, error) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	if s.getErr != nil {
 		return nil, s.getErr
 	}
 	f, ok := s.files[name]
 	if !ok {
 		return nil, fmt.Errorf("file not found: %s", name)
 	}
 	cp := *f
 	cp.Data = append([]byte(nil), f.Data...)
 	return &cp, nil
 }
 func (s *fakeStorage) Delete(_ context.Context, name string) error {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	delete(s.files, name)
 	return nil
 }
 func (s *fakeStorage) MimeType(filename string) string {
 	return ""
 }
 func (s *fakeStorage) names() []string {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	res := make([]string, 0, len(s.files))
 	for name := range s.files {
 		res = append(res, name)
 	}
 	return res
 }
 // fakeScenariosRepo — минимальная in-memory реализация scenariosRepository.
 type fakeScenariosRepo struct {
 	mu        sync.Mutex
 	byID      map[int]*repos.Scenario
 	nextID    int
 	addErr    error
 	updateErr error
 	storyErr  error
 }
 func newFakeScenariosRepo() *fakeScenariosRepo {
 	return &fakeScenariosRepo{
 		byID:   map[int]*repos.Scenario{},
 		nextID: 0,
 	}
 }
 func (r *fakeScenariosRepo) AddScenario(_ context.Context, name string, authorId int) (int, error) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	if r.addErr != nil {
 		return 0, r.addErr
 	}
 	r.nextID++
 	description := ""
 	r.byID[r.nextID] = &repos.Scenario{
 		ID:          r.nextID,
 		Name:        name,
 		Description: &description,
 		Author:      &repos.User{ID: authorId},
 		Status:      "draft",
 	}
 	return r.nextID, nil
 }
 func (r *fakeScenariosRepo) GetScenariosByAuthorID(_ context.Context, authorId int) ([]*repos.Scenario, error) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	var res []*repos.Scenario
 	for _, s := range r.byID {
 		if s.Author != nil && s.Author.ID == authorId {
 			res = append(res, s)
 		}
 	}
 	return res, nil
 }
 func (r *fakeScenariosRepo) GetScenariosByStatus(_ context.Context, status string) ([]*repos.Scenario, error) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	var res []*repos.Scenario
 	for _, s := range r.byID {
 		if s.Status == status {
 			res = append(res, s)
 		}
 	}
 	return res, nil
 }
 func (r *fakeScenariosRepo) GetScenarioByID(_ context.Context, id int) (*repos.Scenario, error) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	s, ok := r.byID[id]
 	if !ok {
 		return nil, scenarios_repo.ErrScenarioNotFound
 	}
 	return s, nil
 }
 func (r *fakeScenariosRepo) UpdateScenarioByID(_ context.Context, id int, name string, description string, image string) error {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	if r.updateErr != nil {
 		return r.updateErr
 	}
 	s, ok := r.byID[id]
 	if !ok {
 		return scenarios_repo.ErrScenarioNotFound
 	}
 	s.Name = name
 	s.Description = &description
 	s.Image = &image
 	return nil
 }
 func (r *fakeScenariosRepo) UpdateScenarioStatusByID(_ context.Context, id int, status string, allowPublished bool) (bool, error) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	s, ok := r.byID[id]
 	if !ok {
 		return false, scenarios_repo.ErrScenarioNotFound
 	}
 	if !allowPublished && s.Status == "public" {
 		return false, nil
 	}
 	s.Status = status
 	return true, nil
 }
 func (r *fakeScenariosRepo) DeleteScenarioByID(_ context.Context, id int, allowPublished bool) (bool, error) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	s, ok := r.byID[id]
 	if !ok {
 		return false, scenarios_repo.ErrScenarioNotFound
 	}
 	if !allowPublished && s.Status == "public" {
 		return false, nil
 	}
 	s.IsDeleted = true
 	return true, nil
 }
 func (r *fakeScenariosRepo) GetStoryByScenarioID(_ context.Context, id int) (string, error) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	if r.storyErr != nil {
 		return "", r.storyErr
 	}
 	s, ok := r.byID[id]
 	if !ok {
 		return "", scenarios_repo.ErrScenarioNotFound
 	}
 	return s.Scenario, nil
 }
 func (r *fakeScenariosRepo) UpdateStoryByScenarioID(_ context.Context, id int, story string) error {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	s, ok := r.byID[id]
 	if !ok {
 		return scenarios_repo.ErrScenarioNotFound
 	}
 	s.Scenario = story
 	return nil
 }
 func (r *fakeScenariosRepo) get(id int) *repos.Scenario {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	return r.byID[id]
 }
 func newTestService(repo *fakeScenariosRepo, storage *fakeStorage) *ScenarioService {
 	if repo == nil {
 		repo = newFakeScenariosRepo()
 	}
 	if storage == nil {
 		storage = newFakeStorage()
 	}
 	return NewScenarioService(repo, nil, testDomain, storage, scenario_archive.NewScenarioArchive())
 }
 // seedScenario кладёт в repo сценарий с историей и изображениями в storage.
 func seedScenario(t *testing.T, repo *fakeScenariosRepo, storage *fakeStorage) *repos.Scenario {
 	t.Helper()
 	description := "Детективная история"
 	image := "cover.png"
 	scenario := &repos.Scenario{
 		ID:          1,
 		Name:        "Ночной клуб",
 		Description: &description,
 		Image:       &image,
 		Author:      &repos.User{ID: 7},
 		Status:      "draft",
 		Scenario: `{"places":[
 			{"code":"club","name":"Клуб","text":"Тёмный зал","image":"club.png","applications":[{"name":"Билет","image":"ticket.jpg"}]},
 			{"code":"parking","name":"Парковка","text":"Пусто","image":"club.png"}
 		]}`,
 	}
 	repo.byID[scenario.ID] = scenario
 	_ = storage.Put(context.Background(), &file_storage.File{Name: "cover.png", Data: []byte("cover-bytes")})
 	_ = storage.Put(context.Background(), &file_storage.File{Name: "club.png", Data: []byte("club-bytes")})
 	_ = storage.Put(context.Background(), &file_storage.File{Name: "ticket.jpg", Data: []byte("ticket-bytes")})
 	return scenario
 }
 func TestUploadArchive(t *testing.T) {
 	repo := newFakeScenariosRepo()
 	srcStorage := newFakeStorage()
 	seedScenario(t, repo, srcStorage)
 	// Собираем архив как при скачивании (Pack через storage).
 	svc := newTestService(repo, srcStorage)
 	archive, _, err := svc.DownloadArchive(context.Background(), 1, 7, false)
 	if err != nil {
 		t.Fatalf("DownloadArchive: %v", err)
 	}
 	// Импортируем в «чистые» repo и storage.
 	importRepo := newFakeScenariosRepo()
 	importStorage := newFakeStorage()
 	importSvc := newTestService(importRepo, importStorage)
 	id, err := importSvc.UploadArchive(context.Background(), archive, 42)
 	if err != nil {
 		t.Fatalf("UploadArchive: %v", err)
 	}
 	if id != 1 {
 		t.Errorf("id = %d, want 1", id)
 	}
 	saved := importRepo.get(id)
 	if saved == nil {
 		t.Fatal("сценарий не создан")
 	}
 	if saved.Name != "Ночной клуб" {
 		t.Errorf("Name = %q", saved.Name)
 	}
 	if saved.Description == nil || *saved.Description != "Детективная история" {
 		t.Errorf("Description = %v", saved.Description)
 	}
 	if saved.Status != "draft" {
 		t.Errorf("Status = %q, want draft", saved.Status)
 	}
 	if saved.Author == nil || saved.Author.ID != 42 {
 		t.Errorf("Author = %+v, want id 42", saved.Author)
 	}
 	// Ссылки переписаны на новые имена без префикса images/.
 	if saved.Image == nil || strings.HasPrefix(*saved.Image, "images/") || *saved.Image == "cover.png" {
 		t.Errorf("Image = %v, want новое случайное имя без images/", saved.Image)
 	}
 	story := &storytelling.Story{}
 	if err := json.Unmarshal([]byte(saved.Scenario), story); err != nil {
 		t.Fatalf("story не разобрался: %v", err)
 	}
 	if len(story.Places) != 2 {
 		t.Fatalf("places = %d, want 2", len(story.Places))
 	}
 	club := story.Places[0]
 	if club.Image == "" || strings.HasPrefix(club.Image, "images/") || club.Image == "club.png" {
 		t.Errorf("place image = %q, want новое имя", club.Image)
 	}
 	if len(club.Applications) != 1 || strings.HasPrefix(club.Applications[0].Image, "images/") {
 		t.Errorf("application image = %+v, want новое имя", club.Applications)
 	}
 	// Одна и та же картинка в двух точках — одно новое имя.
 	if story.Places[1].Image != club.Image {
 		t.Errorf("дублирующаяся картинка переписана по-разному: %q и %q", story.Places[1].Image, club.Image)
 	}
 	// Файлы загружены в storage под новыми именами с правильным содержимым.
 	files := importStorage.names()
 	if len(files) != 3 {
 		t.Fatalf("storage files = %v, want 3", files)
 	}
 	contents := map[string]bool{}
 	for _, name := range files {
 		file, err := importStorage.Get(context.Background(), name)
 		if err != nil {
 			t.Fatalf("Get(%q): %v", name, err)
 		}
 		contents[string(file.Data)] = true
 	}
 	for _, want := range []string{"cover-bytes", "club-bytes", "ticket-bytes"} {
 		if !contents[want] {
 			t.Errorf("в storage нет содержимого %q, есть: %v", want, contents)
 		}
 	}
 }
 func TestUploadArchiveMissingImage(t *testing.T) {
 	repo := newFakeScenariosRepo()
 	storage := newFakeStorage()
 	svc := newTestService(repo, storage)
 	// Архив ссылается на images/missing.png, файла в архиве нет.
 	archive := buildRawArchive(t, map[string][]byte{
 		scenario_archive.FileName: mustJSON(t, scenario_archive.ScenarioJSON{
 			Version: scenario_archive.Version,
 			Name:    "Тест",
 			Image:   "images/missing.png",
 			Story:   &storytelling.Story{Places: []*storytelling.Place{{Code: "p", Name: "P"}}},
 		}),
 	})
 	if _, err := svc.UploadArchive(context.Background(), archive, 1); err == nil {
 		t.Fatal("UploadArchive должен вернуть ошибку при отсутствующем файле")
 	}
 	if len(storage.names()) != 0 {
 		t.Errorf("storage не должен содержать файлов: %v", storage.names())
 	}
 }
 func TestUploadArchiveExternalURLKept(t *testing.T) {
 	repo := newFakeScenariosRepo()
 	storage := newFakeStorage()
 	svc := newTestService(repo, storage)
 	archive := buildRawArchive(t, map[string][]byte{
 		scenario_archive.FileName: mustJSON(t, scenario_archive.ScenarioJSON{
 			Version: scenario_archive.Version,
 			Name:    "Тест",
 			Image:   "https://example.com/cover.png",
 			Story:   &storytelling.Story{Places: []*storytelling.Place{{Code: "p", Name: "P", Image: "http://other.example/x.png"}}},
 		}),
 	})
 	id, err := svc.UploadArchive(context.Background(), archive, 1)
 	if err != nil {
 		t.Fatalf("UploadArchive: %v", err)
 	}
 	saved := repo.get(id)
 	if saved.Image == nil || *saved.Image != "https://example.com/cover.png" {
 		t.Errorf("Image = %v, внешний URL должен остаться без изменений", saved.Image)
 	}
 	if len(storage.names()) != 0 {
 		t.Errorf("storage не должен содержать файлов: %v", storage.names())
 	}
 }
 func TestUploadArchiveCleanupOnRepoError(t *testing.T) {
 	repo := newFakeScenariosRepo()
 	repo.addErr = errors.New("db is down")
 	storage := newFakeStorage()
 	svc := newTestService(repo, storage)
 	archive := buildRawArchive(t, map[string][]byte{
 		scenario_archive.FileName: mustJSON(t, scenario_archive.ScenarioJSON{
 			Version: scenario_archive.Version,
 			Name:    "Тест",
 			Image:   "images/x.png",
 			Story:   &storytelling.Story{Places: []*storytelling.Place{{Code: "p", Name: "P"}}},
 		}),
 		"images/x.png": []byte("x"),
 	})
 	if _, err := svc.UploadArchive(context.Background(), archive, 1); err == nil {
 		t.Fatal("UploadArchive должен вернуть ошибку репозитория")
 	}
 	// Загруженные файлы удалены (best-effort), orphan-объектов не осталось.
 	if len(storage.names()) != 0 {
 		t.Errorf("после ошибки БД storage должен быть пуст: %v", storage.names())
 	}
 }
 func TestUploadArchiveDeletesRowOnPartialFailure(t *testing.T) {
 	repo := newFakeScenariosRepo()
 	repo.updateErr = errors.New("db is down")
 	storage := newFakeStorage()
 	svc := newTestService(repo, storage)
 	archive := buildRawArchive(t, map[string][]byte{
 		scenario_archive.FileName: mustJSON(t, scenario_archive.ScenarioJSON{
 			Version: scenario_archive.Version,
 			Name:    "Тест",
 			Image:   "images/x.png",
 			Story:   &storytelling.Story{Places: []*storytelling.Place{{Code: "p", Name: "P"}}},
 		}),
 		"images/x.png": []byte("x"),
 	})
 	if _, err := svc.UploadArchive(context.Background(), archive, 1); err == nil {
 		t.Fatal("UploadArchive должен вернуть ошибку репозитория")
 	}
 	// Строка помечена удалённой (best-effort, soft delete как в проде), файлы зачищены.
 	if got := repo.get(1); got == nil || !got.IsDeleted {
 		t.Errorf("строка сценария должна быть удалена после частичного сбоя, осталась: %+v", got)
 	}
 	if len(storage.names()) != 0 {
 		t.Errorf("после частичного сбоя storage должен быть пуст: %v", storage.names())
 	}
 }
 func TestDownloadArchive(t *testing.T) {
 	repo := newFakeScenariosRepo()
 	storage := newFakeStorage()
 	seedScenario(t, repo, storage)
 	svc := newTestService(repo, storage)
 	data, name, err := svc.DownloadArchive(context.Background(), 1, 7, false)
 	if err != nil {
 		t.Fatalf("DownloadArchive: %v", err)
 	}
 	if name != "Ночной клуб" {
 		t.Errorf("name = %q", name)
 	}
 	bundle, err := scenario_archive.NewScenarioArchive().Unpack(data)
 	if err != nil {
 		t.Fatalf("Unpack: %v", err)
 	}
 	if bundle.Scenario.Name != "Ночной клуб" {
 		t.Errorf("scenario name = %q", bundle.Scenario.Name)
 	}
 	if bundle.Scenario.Image != "images/cover.png" {
 		t.Errorf("scenario image = %q", bundle.Scenario.Image)
 	}
 	for _, want := range []string{"images/cover.png", "images/club.png", "images/ticket.jpg"} {
 		if _, ok := bundle.Files[want]; !ok {
 			t.Errorf("в архиве нет %q", want)
 		}
 	}
 }
 func TestDownloadArchiveNotOwner(t *testing.T) {
 	repo := newFakeScenariosRepo()
 	storage := newFakeStorage()
 	seedScenario(t, repo, storage)
 	svc := newTestService(repo, storage)
 	if _, _, err := svc.DownloadArchive(context.Background(), 1, 99, false); !errors.Is(err, ErrScenarioNotOwner) {
 		t.Errorf("err = %v, want ErrScenarioNotOwner", err)
 	}
 	// Админ может скачать чужой сценарий.
 	if _, _, err := svc.DownloadArchive(context.Background(), 1, 99, true); err != nil {
 		t.Errorf("админ: err = %v", err)
 	}
 }
 func TestDownloadArchiveNotFound(t *testing.T) {
 	repo := newFakeScenariosRepo()
 	storage := newFakeStorage()
 	svc := newTestService(repo, storage)
 	if _, _, err := svc.DownloadArchive(context.Background(), 404, 1, true); !errors.Is(err, scenarios_repo.ErrScenarioNotFound) {
 		t.Errorf("err = %v, want ErrScenarioNotFound", err)
 	}
 }
 func TestDownloadArchiveMissingImage(t *testing.T) {
 	repo := newFakeScenariosRepo()
 	storage := newFakeStorage()
 	seedScenario(t, repo, storage)
 	_ = storage.Delete(context.Background(), "ticket.jpg")
 	svc := newTestService(repo, storage)
 	if _, _, err := svc.DownloadArchive(context.Background(), 1, 7, false); err == nil {
 		t.Fatal("DownloadArchive должен вернуть ошибку при недоступном изображении")
 	}
 }
 // buildRawArchive собирает zip из произвольных записей (для тестов импорта).
 func buildRawArchive(t *testing.T, entries map[string][]byte) []byte {
 	t.Helper()
 	var buf bytes.Buffer
 	zw := zip.NewWriter(&buf)
 	for name, content := range entries {
 		w, err := zw.Create(name)
 		if err != nil {
 			t.Fatalf("Create(%q): %v", name, err)
 		}
 		if _, err := w.Write(content); err != nil {
 			t.Fatalf("Write(%q): %v", name, err)
 		}
 	}
 	if err := zw.Close(); err != nil {
 		t.Fatalf("Close: %v", err)
 	}
 	return buf.Bytes()
 }
 func mustJSON(t *testing.T, v scenario_archive.ScenarioJSON) []byte {
 	t.Helper()
 	b, err := json.Marshal(v)
 	if err != nil {
 		t.Fatalf("json.Marshal: %v", err)
 	}
 	return b
 }
@@ -0,0 +1,197 @@
 package users_service
 import (
 	"fmt"
 	"html"
 	"strings"
 )
 // Шаблоны писем сервиса. Структура по базе знаний копирайтера (email.md):
 // приветствие → контекст («почему это письмо») → ценность (данные для входа)
 // → CTA → подпись → P.S. Письма транзакционные, но по форме — «человек
 // человеку»: Gmail и другие почтовики агрессивнее фильтруют короткие
 // «роботные» письма без структуры.
 //
 // Каждое письмо формируется в двух версиях: text/plain (для старых клиентов
 // и фильтров) и text/html (для отображения); sender собирает их в
 // multipart/alternative.
 const (
 	// welcomeSubject — тема письма о регистрации: конкретика без КАПСА и
 	// кликбейта, до 50 символов (видно на мобильных целиком).
 	welcomeSubject = "Твой доступ к «Вечернему детективу»"
 	// resetSubject — тема письма о сбросе пароля.
 	resetSubject = "Новый пароль для «Вечернего детектива»"
 )
 // welcomePlain возвращает текстовую версию письма о регистрации.
 func welcomePlain(username, email, password, loginURL string) string {
 	var b strings.Builder
 	b.WriteString(greeting(username))
 	b.WriteString("\n\n")
 	b.WriteString("Твоя регистрация в «Вечернем детективе» прошла. Данные для входа:\n\n")
 	b.WriteString("  Логин: ")
 	b.WriteString(email)
 	b.WriteString("\n")
 	b.WriteString("  Пароль: ")
 	b.WriteString(password)
 	b.WriteString("\n\n")
 	if loginURL != "" {
 		b.WriteString("Войти в игру: ")
 		b.WriteString(loginURL)
 		b.WriteString("\n\n")
 	}
 	b.WriteString("Если ты не регистрировался — просто проигнорируй это письмо.\n\n")
 	b.WriteString("— Команда «Вечернего детектива»\n")
 	b.WriteString("P.S. Сохрани это письмо: пароль понадобится для входа.")
 	return sanitizeLine(b.String())
 }
 // welcomeHTML возвращает HTML-версию письма о регистрации.
 func welcomeHTML(username, email, password, loginURL string) string {
 	var content strings.Builder
 	content.WriteString("<p>Привет, <strong>")
 	content.WriteString(html.EscapeString(username))
 	content.WriteString("</strong>!</p>\n")
 	content.WriteString("<p>Твоя регистрация в «Вечернем детективе» прошла. Данные для входа:</p>\n")
 	content.WriteString(credentialsBlockHTML(email, password))
 	if loginURL != "" {
 		content.WriteString(buttonHTML(loginURL, "Войти в игру"))
 	}
 	content.WriteString("<p style=\"color:#777777; font-size:13px;\">Если ты не регистрировался — просто проигнорируй это письмо.</p>")
 	return wrapHTML(content.String())
 }
 // resetPlain возвращает текстовую версию письма о сбросе пароля.
 func resetPlain(username, email, password, loginURL string) string {
 	var b strings.Builder
 	b.WriteString(greeting(username))
 	b.WriteString("\n\n")
 	b.WriteString("Ты запросил сброс пароля в «Вечернем детективе». Новый пароль для входа:\n\n")
 	b.WriteString("  Логин: ")
 	b.WriteString(email)
 	b.WriteString("\n")
 	b.WriteString("  Пароль: ")
 	b.WriteString(password)
 	b.WriteString("\n\n")
 	if loginURL != "" {
 		b.WriteString("Войти в игру: ")
 		b.WriteString(loginURL)
 		b.WriteString("\n\n")
 	}
 	b.WriteString("Никому не сообщай пароль и не пересылай это письмо.\n")
 	b.WriteString("Если это был не ты — ответь на это письмо: мы поможем защитить аккаунт.\n\n")
 	b.WriteString("— Команда «Вечернего детектива»\n")
 	return sanitizeLine(b.String())
 }
 // resetHTML возвращает HTML-версию письма о сбросе пароля.
 func resetHTML(username, email, password, loginURL string) string {
 	var content strings.Builder
 	content.WriteString("<p>Привет, <strong>")
 	content.WriteString(html.EscapeString(username))
 	content.WriteString("</strong>!</p>\n")
 	content.WriteString("<p>Ты запросил сброс пароля в «Вечернем детективе». Новый пароль для входа:</p>\n")
 	content.WriteString(credentialsBlockHTML(email, password))
 	if loginURL != "" {
 		content.WriteString(buttonHTML(loginURL, "Войти в игру"))
 	}
 	content.WriteString("<p>Никому не сообщай пароль и не пересылай это письмо.</p>\n")
 	content.WriteString("<p style=\"color:#777777; font-size:13px;\">Если это был не ты — ответь на это письмо: мы поможем защитить аккаунт.</p>")
 	return wrapHTML(content.String())
 }
 // greeting возвращает приветствие с именем пользователя; при пустом имени —
 // без обращения, чтобы не было «Привет, !».
 func greeting(username string) string {
 	username = sanitizeLine(strings.TrimSpace(username))
 	if username == "" {
 		return "Привет!"
 	}
 	return fmt.Sprintf("Привет, %s!", username)
 }
 // credentialsBlockHTML — блок «Логин / Пароль» в табличной вёрстке,
 // совместимой с Gmail.
 func credentialsBlockHTML(email, password string) string {
 	return `<table role="presentation" cellpadding="0" cellspacing="0" style="margin:16px 0; border:1px solid #e3ddd2; border-radius:6px; background-color:#faf8f5; width:100%;">
 <tr>
 <td style="padding:12px 16px; font-size:14px; color:#555555; width:120px;">Логин</td>
 <td style="padding:12px 16px; font-size:14px; color:#222222;"><strong>` + html.EscapeString(email) + `</strong></td>
 </tr>
 <tr>
 <td style="padding:12px 16px; font-size:14px; color:#555555; width:120px; border-top:1px solid #e3ddd2;">Пароль</td>
 <td style="padding:12px 16px; font-size:14px; color:#1a1a2e; border-top:1px solid #e3ddd2;"><strong>` + html.EscapeString(password) + `</strong></td>
 </tr>
 </table>`
 }
 // buttonHTML — CTA-кнопка табличной вёрсткой (Gmail не поддерживает
 // margin/padding на <a>, поэтому отступы — на ячейке <td>).
 func buttonHTML(link, label string) string {
 	return `<table role="presentation" cellpadding="0" cellspacing="0" style="margin:20px 0;">
 <tr>
 <td style="border-radius:6px; background-color:#c9a227;">
 <a href="` + html.EscapeString(link) + `" style="display:inline-block; padding:12px 28px; color:#1a1a2e; font-weight:bold; text-decoration:none; font-size:15px; border-radius:6px;">` + html.EscapeString(label) + `</a>
 </td>
 </tr>
 </table>`
 }
 // wrapHTML — каркас письма: тёмная шапка с названием сервиса, контент,
 // подвал с дисклеймером. Только табличная вёрстка и inline-стили: внешние
 // таблицы стилей Gmail вырезает.
 func wrapHTML(content string) string {
 	return `<!DOCTYPE html>
 <html lang="ru">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1.0">
 </head>
 <body style="margin:0; padding:0; background-color:#f4f1ec; font-family:Arial, Helvetica, sans-serif;">
 <table role="presentation" width="100%" cellpadding="0" cellspacing="0" style="background-color:#f4f1ec; padding:24px 0;">
 <tr><td align="center">
 <table role="presentation" width="600" cellpadding="0" cellspacing="0" style="max-width:600px; width:100%; background-color:#ffffff; border-radius:8px; overflow:hidden;">
 <tr>
 <td style="background-color:#1a1a2e; padding:20px 28px;">
 <span style="color:#ffffff; font-size:20px; font-weight:bold; letter-spacing:1px;">ВЕЧЕРНИЙ ДЕТЕКТИВ</span>
 </td>
 </tr>
 <tr>
 <td style="padding:28px; color:#222222; font-size:15px; line-height:1.6;">
 ` + content + `
 </td>
 </tr>
 <tr>
 <td style="padding:20px 28px; background-color:#faf8f5; color:#777777; font-size:12px; line-height:1.5;">
 Это автоматическое письмо сервиса «Вечерний детектив».<br>
 Если ты получил его по ошибке — просто ответь на это письмо.
 </td>
 </tr>
 </table>
 </td></tr>
 </table>
 </body>
 </html>`
 }
 // sanitizeLine убирает переносы строк из пользовательского ввода,
 // вставляемого в тело письма (защита от инъекции строк в DATA-фазу SMTP).
 func sanitizeLine(s string) string {
 	return strings.NewReplacer("\r", "", "\n", "").Replace(s)
 }
 // loginURL нормализует адрес фронтенда для ссылки в письме: срезает
 // завершающий слэш и допускает только http(s). Пустое или некорректное
 // значение — ссылка в письма не добавляется.
 func loginURL(baseURL string) string {
 	baseURL = strings.TrimSpace(baseURL)
 	baseURL = strings.TrimRight(baseURL, "/")
 	if baseURL == "" {
 		return ""
 	}
 	if !strings.HasPrefix(baseURL, "http://") && !strings.HasPrefix(baseURL, "https://") {
 		return ""
 	}
 	return baseURL
 }
@@ -9,28 +9,67 @@ import (
 	"evening_detective_server/internal/modules/roles"
 	"evening_detective_server/internal/repos"
 	"evening_detective_server/internal/repos/refresh_tokens_repo"
 	"evening_detective_server/internal/repos/user_agreements_repo"
 	"evening_detective_server/internal/repos/users_repo"
 	"fmt"
 	"log"
 	"net/mail"
 	"slices"
 	"strings"
 	"time"
 	"golang.org/x/crypto/bcrypt"
 )
 // Версии документов, акцепт которых фиксируется. Должны совпадать с
 // редакциями, опубликованными по постоянным URL (/api/terms и /api/privacy,
 // rpc GetTerms/GetPrivacy, текст встраивается из пакета docs): при изменении
 // текста документа версия ОБЯЗАНА увеличиваться, иначе повторный акцепт
 // не будет зафиксирован как согласие с новой редакцией
 // (UNIQUE (user_id, agreement_type, version)).
 const (
 	termsVersion   = "1.0"
 	privacyVersion = "1.0"
 )
 // usersRepository — граница доступа к данным пользователей, реализуемая
 // *users_repo.UsersRepo; интерфейс позволяет тестировать сервис без БД.
 type usersRepository interface {
 	AddUserWithAgreements(
 		ctx context.Context,
 		username string,
 		email string,
 		passwordHash string,
 		roles []string,
 		agreements []user_agreements_repo.Agreement,
 	) (int, error)
 	UpdateUserPassword(ctx context.Context, email string, passwordHash string) error
 	GetUserByEmail(ctx context.Context, email string) (*repos.User, error)
 	GetUserByID(ctx context.Context, id int) (*repos.User, error)
 	GetUsers(ctx context.Context) ([]*repos.User, error)
 	AddUserRole(ctx context.Context, userId int, role string) error
 	DeleteUserRole(ctx context.Context, userId int, role string) error
 	DeleteUser(ctx context.Context, userId int) error
 }
 type UsersService struct {
-	usersRepo         *users_repo.UsersRepo
+	usersRepo         usersRepository
 	passwordGenerator password_generator.IPasswordGenerator
 	emailSender       email_sender.IEmailSender
 	processorJWT      processor_jwt.IProcessorJWT
 	refreshTokensRepo *refresh_tokens_repo.RefreshTokensRepo
 	// appBaseURL — публичный адрес фронтенда для ссылки «Войти в игру» в
 	// письмах; пустое значение — ссылка не добавляется.
 	appBaseURL string
 }
 func NewUsersService(
-	usersRepo *users_repo.UsersRepo,
+	usersRepo usersRepository,
 	passwordGenerator password_generator.IPasswordGenerator,
 	emailSender email_sender.IEmailSender,
 	processorJWT processor_jwt.IProcessorJWT,
 	refreshTokensRepo *refresh_tokens_repo.RefreshTokensRepo,
 	appBaseURL string,
 ) *UsersService {
 	return &UsersService{
 		usersRepo:         usersRepo,
@@ -38,14 +77,31 @@ func NewUsersService(
 		emailSender:       emailSender,
 		processorJWT:      processorJWT,
 		refreshTokensRepo: refreshTokensRepo,
 		appBaseURL:        loginURL(appBaseURL),
 	}
 }
 // ErrTermsNotAccepted — регистрация невозможна без акцепта соглашений.
 var ErrTermsNotAccepted = errors.New("Необходимо принять Пользовательское соглашение и Политику конфиденциальности")
 func (s *UsersService) AddUser(
 	ctx context.Context,
 	username string,
 	email string,
 	acceptTerms bool,
 	acceptPrivacy bool,
 	ip string,
 	userAgent string,
 ) error {
 	if !acceptTerms || !acceptPrivacy {
 		return ErrTermsNotAccepted
 	}
 	email = normalizeEmail(email)
 	if err := validateEmail(email); err != nil {
 		return err
 	}
 	password, err := s.passwordGenerator.Generate()
 	if err != nil {
 		return err
@@ -54,30 +110,92 @@ func (s *UsersService) AddUser(
 	if err != nil {
 		return err
 	}
-	err = s.usersRepo.AddUser(
+	// Создание пользователя и фиксация акцептов — в одной транзакции:
 	// без записей о согласиях пользователь не существует.
 	id, err := s.usersRepo.AddUserWithAgreements(
 		ctx,
 		username,
 		email,
 		string(hashedPassword),
 		[]string{"user"},
 		[]user_agreements_repo.Agreement{
 			{
 				AgreementType: user_agreements_repo.AgreementTypeTerms,
 				Version:       termsVersion,
 				IP:            ip,
 				UserAgent:     userAgent,
 			},
 			{
 				AgreementType: user_agreements_repo.AgreementTypePrivacy,
 				Version:       privacyVersion,
 				IP:            ip,
 				UserAgent:     userAgent,
 			},
 		},
 	)
 	if err != nil {
 		return err
 	}
 	// Консистентность ответа и состояния БД: если письмо с паролем не
 	// ушло, пользователь не должен оставаться в системе «полусозданным»
 	// (клиент получит ошибку и повторит регистрацию). Компенсация —
 	// удаление созданного пользователя. Выполняется вне отменённого
 	// контекста: письмо могло упасть именно из-за истечения таймаута ctx,
 	// и тогда тот же ctx не дал бы выполнить удаление.
 	err = s.emailSender.Send(ctx, email_sender.Message{
 		To:      email,
-		Subject: "Приветствую тебя, детектив!",
+		Subject: welcomeSubject,
-		Body:    fmt.Sprintf("Вот твой пароль для входа в систему: %s", password),
+		Body:    welcomePlain(username, email, password, s.appBaseURL),
 		HTML:    welcomeHTML(username, email, password, s.appBaseURL),
 	})
 	if err != nil {
 		if delErr := s.usersRepo.DeleteUser(context.WithoutCancel(ctx), id); delErr != nil {
 			log.Printf("email: отправка не удалась (%v) и компенсация не выполнена: %v", err, delErr)
 		}
 		return fmt.Errorf("email send: %w", err)
 	}
 	return nil
 }
 // DeleteAccount удаляет учётную запись и все персональные данные пользователя
 // (ст. 21 152-ФЗ). Требует подтверждения паролем: обладатель украденного
 // access-токена не должен мочь удалить чужой аккаунт.
 func (s *UsersService) DeleteAccount(
 	ctx context.Context,
 	userId int,
 	password string,
 ) error {
 	user, err := s.usersRepo.GetUserByID(ctx, userId)
 	if err != nil {
 		return err
 	}
 	if err = bcrypt.CompareHashAndPassword([]byte(user.PasswordHash), []byte(password)); err != nil {
 		return errors.New("Неверный пароль")
 	}
 	return s.usersRepo.DeleteUser(ctx, userId)
 }
 func (s *UsersService) RefreshPassword(
 	ctx context.Context,
 	email string,
 ) error {
 	email = normalizeEmail(email)
 	if err := validateEmail(email); err != nil {
 		return err
 	}
 	// Анти-enumeration: ответ одинаков для существующего и несуществующего
 	// адреса, письмо отправляется только реальному пользователю.
 	user, err := s.usersRepo.GetUserByEmail(ctx, email)
 	if err != nil {
 		if errors.Is(err, users_repo.ErrUserNotFound) {
 			return nil
 		}
 		return err
 	}
 	password, err := s.passwordGenerator.Generate()
 	if err != nil {
 		return err
@@ -87,22 +205,42 @@ func (s *UsersService) RefreshPassword(
 		return err
 	}
-	err = s.usersRepo.UpdateUserPassword(
+	// Письмо отправляется ДО смены пароля: при сбое отправки пароль
-		ctx,
+	// остаётся прежним и аккаунт не блокируется (иначе старый пароль уже
-		email,
+	// не работает, а новый пользователь так и не узнал).
-		string(hashedPassword),
+	err = s.emailSender.Send(ctx, email_sender.Message{
-	)
+		To:      user.Email,
 		Subject: resetSubject,
 		Body:    resetPlain(user.Username, user.Email, password, s.appBaseURL),
 		HTML:    resetHTML(user.Username, user.Email, password, s.appBaseURL),
 	})
 	if err != nil {
-		return err
+		return fmt.Errorf("email send: %w", err)
 	}
-	err = s.emailSender.Send(ctx, email_sender.Message{
+	return s.usersRepo.UpdateUserPassword(ctx, user.Email, string(hashedPassword))
-		To:      email,
+}
 		Subject: "Приветствую тебя, детектив!",
 		Body:    fmt.Sprintf("Вот твой новый пароль для входа в систему, не теряй: %s", password),
 	})
-	return err
+// normalizeEmail приводит адрес к каноническому виду (без пробелов, нижний
 // регистр): "User@Example.COM " и "user@example.com" — один аккаунт.
 func normalizeEmail(email string) string {
 	return strings.ToLower(strings.TrimSpace(email))
 }
 // validateEmail проверяет, что строка является одиночным email-адресом.
 func validateEmail(email string) error {
 	if email == "" {
 		return errors.New("Email не указан")
 	}
 	addr, err := mail.ParseAddress(email)
 	if err != nil {
 		return errors.New("Некорректный email")
 	}
 	// Отклоняем форму "Имя <a@b.c>" и всё, что не является чистым адресом.
 	if !strings.EqualFold(addr.Address, email) {
 		return errors.New("Некорректный email")
 	}
 	return nil
 }
 func (s *UsersService) Login(
@@ -110,9 +248,11 @@ func (s *UsersService) Login(
 	email string,
 	password string,
 ) (string, string, error) {
 	// Email нормализуется так же, как при регистрации: иначе пользователь,
 	// зарегистрировавшийся как user@example.com, не войдёт с User@Example.COM.
 	user, err := s.usersRepo.GetUserByEmail(
 		ctx,
-		email,
+		normalizeEmail(email),
 	)
 	if err != nil {
 		return "", "", err
@@ -0,0 +1,348 @@
 package users_service
 import (
 	"context"
 	"errors"
 	"evening_detective_server/internal/modules/email_sender"
 	"evening_detective_server/internal/modules/password_generator"
 	"evening_detective_server/internal/modules/processor_jwt"
 	"evening_detective_server/internal/repos"
 	"evening_detective_server/internal/repos/refresh_tokens_repo"
 	"evening_detective_server/internal/repos/user_agreements_repo"
 	"evening_detective_server/internal/repos/users_repo"
 	"strings"
 	"sync"
 	"testing"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 type fakeSender struct {
 	mu       sync.Mutex
 	messages []email_sender.Message
 	err      error
 }
 func (f *fakeSender) Send(_ context.Context, m email_sender.Message) error {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 	f.messages = append(f.messages, m)
 	return f.err
 }
 func (f *fakeSender) sent() []email_sender.Message {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 	return append([]email_sender.Message(nil), f.messages...)
 }
 // fakeRepo — минимальная in-memory реализация usersRepository для тестов
 // сервиса без БД.
 type fakeRepo struct {
 	mu     sync.Mutex
 	users  map[string]*repos.User
 	byID   map[int]*repos.User
 	nextID int
 }
 func newFakeRepo() *fakeRepo {
 	return &fakeRepo{
 		users:  map[string]*repos.User{},
 		byID:   map[int]*repos.User{},
 		nextID: 1,
 	}
 }
 func (r *fakeRepo) AddUserWithAgreements(
 	_ context.Context,
 	username, email, passwordHash string,
 	roles []string,
 	_ []user_agreements_repo.Agreement,
 ) (int, error) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	if _, ok := r.users[email]; ok {
 		return 0, errors.New("Username или email уже используется")
 	}
 	id := r.nextID
 	r.nextID++
 	u := &repos.User{ID: id, Username: username, Email: email, PasswordHash: passwordHash, Roles: roles}
 	r.users[email] = u
 	r.byID[id] = u
 	return id, nil
 }
 func (r *fakeRepo) UpdateUserPassword(_ context.Context, email, passwordHash string) error {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	u, ok := r.users[email]
 	if !ok {
 		return users_repo.ErrUserNotFound
 	}
 	u.PasswordHash = passwordHash
 	return nil
 }
 func (r *fakeRepo) GetUserByEmail(_ context.Context, email string) (*repos.User, error) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	u, ok := r.users[email]
 	if !ok {
 		return nil, users_repo.ErrUserNotFound
 	}
 	return u, nil
 }
 func (r *fakeRepo) GetUserByID(_ context.Context, id int) (*repos.User, error) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	u, ok := r.byID[id]
 	if !ok {
 		return nil, users_repo.ErrUserNotFound
 	}
 	return u, nil
 }
 func (r *fakeRepo) GetUsers(_ context.Context) ([]*repos.User, error) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	out := make([]*repos.User, 0, len(r.users))
 	for _, u := range r.users {
 		out = append(out, u)
 	}
 	return out, nil
 }
 func (r *fakeRepo) AddUserRole(_ context.Context, _ int, _ string) error { return nil }
 func (r *fakeRepo) DeleteUserRole(_ context.Context, _ int, _ string) error { return nil }
 func (r *fakeRepo) DeleteUser(_ context.Context, userId int) error {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	u, ok := r.byID[userId]
 	if !ok {
 		return users_repo.ErrUserNotFound
 	}
 	delete(r.byID, userId)
 	delete(r.users, u.Email)
 	return nil
 }
 func (r *fakeRepo) userCount() int {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	return len(r.users)
 }
 func (r *fakeRepo) seed(email, passwordHash string) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	u := &repos.User{ID: r.nextID, Email: email, PasswordHash: passwordHash}
 	r.nextID++
 	r.users[email] = u
 	r.byID[u.ID] = u
 }
 func newTestService(repo usersRepository, sender email_sender.IEmailSender) *UsersService {
 	return newTestServiceWithBaseURL(repo, sender, "")
 }
 func newTestServiceWithBaseURL(repo usersRepository, sender email_sender.IEmailSender, baseURL string) *UsersService {
 	// Пул создаётся лениво (pgxpool.New не контактирует с БД) и в этих
 	// тестах не используется.
 	pool, err := pgxpool.New(context.Background(), "postgres://postgres:postgres@localhost:5432/none")
 	if err != nil {
 		panic(err)
 	}
 	return NewUsersService(
 		repo,
 		password_generator.NewGenerator(12),
 		sender,
 		processor_jwt.NewProcessor("test-secret"),
 		refresh_tokens_repo.NewRefreshTokensRepo(pool),
 		baseURL,
 	)
 }
 func TestAddUserSuccess(t *testing.T) {
 	repo := newFakeRepo()
 	sender := &fakeSender{}
 	svc := newTestService(repo, sender)
 	err := svc.AddUser(context.Background(), "detective", " User@Example.COM ", true, true, "1.2.3.4", "ua")
 	if err != nil {
 		t.Fatalf("AddUser: %v", err)
 	}
 	// Email нормализован: пробелы убраны, регистр приведён.
 	if _, ok := repo.users["user@example.com"]; !ok {
 		t.Errorf("пользователь не создан с нормализованным email: %+v", repo.users)
 	}
 	msgs := sender.sent()
 	if len(msgs) != 1 {
 		t.Fatalf("ожидалось 1 письмо, отправлено %d", len(msgs))
 	}
 	if msgs[0].To != "user@example.com" {
 		t.Errorf("письмо ушло на %q, want user@example.com", msgs[0].To)
 	}
 	if !strings.Contains(msgs[0].Subject, "Вечернему детективу") {
 		t.Errorf("неожиданная тема письма: %q", msgs[0].Subject)
 	}
 	if !strings.Contains(msgs[0].Body, "пароль") {
 		t.Error("в текстовой версии письма не упоминается пароль")
 	}
 	if msgs[0].HTML == "" {
 		t.Error("у письма нет HTML-версии — Gmail хуже рендерит такие письма")
 	}
 	// APP_BASE_URL в тесте пуст — кнопка «Войти в игру» не добавляется,
 	// но каркас письма (шапка сервиса) обязан присутствовать.
 	if !strings.Contains(msgs[0].HTML, "ВЕЧЕРНИЙ ДЕТЕКТИВ") {
 		t.Error("HTML-версия письма не содержит шапку сервиса")
 	}
 	if strings.Contains(msgs[0].HTML, "Войти в игру") {
 		t.Error("кнопка входа не должна добавляться без APP_BASE_URL")
 	}
 }
 func TestAddUserWithBaseURLAddsLoginLink(t *testing.T) {
 	repo := newFakeRepo()
 	sender := &fakeSender{}
 	svc := newTestServiceWithBaseURL(repo, sender, "https://evening-detective.crabs-games.art/")
 	err := svc.AddUser(context.Background(), "detective", "user@example.com", true, true, "", "")
 	if err != nil {
 		t.Fatalf("AddUser: %v", err)
 	}
 	msgs := sender.sent()
 	if len(msgs) != 1 {
 		t.Fatalf("ожидалось 1 письмо, отправлено %d", len(msgs))
 	}
 	// Завершающий слэш срезается, ссылка есть и в plain, и в HTML-версии.
 	if !strings.Contains(msgs[0].Body, "https://evening-detective.crabs-games.art") {
 		t.Errorf("plain-версия не содержит ссылку на вход:\n%s", msgs[0].Body)
 	}
 	if !strings.Contains(msgs[0].HTML, "https://evening-detective.crabs-games.art") {
 		t.Error("HTML-версия не содержит ссылку на вход")
 	}
 	if !strings.Contains(msgs[0].HTML, "Войти в игру") {
 		t.Error("HTML-версия не содержит кнопку «Войти в игру»")
 	}
 }
 func TestLoginURLInvalid(t *testing.T) {
 	for _, in := range []string{"", "   ", "ftp://example.com", "not-a-url", "javascript:alert(1)"} {
 		if got := loginURL(in); got != "" {
 			t.Errorf("loginURL(%q) = %q, want пусто", in, got)
 		}
 	}
 }
 func TestAddUserSendFailureCompensates(t *testing.T) {
 	repo := newFakeRepo()
 	sender := &fakeSender{err: errors.New("smtp down")}
 	svc := newTestService(repo, sender)
 	err := svc.AddUser(context.Background(), "detective", "user@example.com", true, true, "", "")
 	if err == nil {
 		t.Fatal("ожидалась ошибка при сбое отправки письма")
 	}
 	// Компенсация: клиенту ошибка, пользователя в БД нет.
 	if repo.userCount() != 0 {
 		t.Errorf("пользователь остался после ошибки отправки: %+v", repo.users)
 	}
 }
 func TestAddUserInvalidEmail(t *testing.T) {
 	repo := newFakeRepo()
 	svc := newTestService(repo, &fakeSender{})
 	err := svc.AddUser(context.Background(), "detective", "not-an-email", true, true, "", "")
 	if err == nil {
 		t.Fatal("ожидалась ошибка валидации email")
 	}
 	if repo.userCount() != 0 {
 		t.Error("пользователь не должен создаваться при невалидном email")
 	}
 }
 func TestAddUserRequiresTerms(t *testing.T) {
 	repo := newFakeRepo()
 	svc := newTestService(repo, &fakeSender{})
 	err := svc.AddUser(context.Background(), "detective", "user@example.com", false, true, "", "")
 	if !errors.Is(err, ErrTermsNotAccepted) {
 		t.Fatalf("ожидался ErrTermsNotAccepted, получено %v", err)
 	}
 	if repo.userCount() != 0 {
 		t.Error("пользователь не должен создаваться без акцепта")
 	}
 }
 func TestRefreshPasswordSuccess(t *testing.T) {
 	repo := newFakeRepo()
 	repo.seed("user@example.com", "old-hash")
 	sender := &fakeSender{}
 	svc := newTestService(repo, sender)
 	// Ввод с пробелами и другим регистром — нормализуется.
 	err := svc.RefreshPassword(context.Background(), "  User@Example.COM ")
 	if err != nil {
 		t.Fatalf("RefreshPassword: %v", err)
 	}
 	if len(sender.sent()) != 1 {
 		t.Fatalf("ожидалось 1 письмо, отправлено %d", len(sender.sent()))
 	}
 	u, _ := repo.GetUserByEmail(context.Background(), "user@example.com")
 	if u.PasswordHash == "old-hash" {
 		t.Error("пароль не изменён")
 	}
 }
 func TestRefreshPasswordSendFailureKeepsPassword(t *testing.T) {
 	repo := newFakeRepo()
 	repo.seed("user@example.com", "old-hash")
 	sender := &fakeSender{err: errors.New("smtp down")}
 	svc := newTestService(repo, sender)
 	err := svc.RefreshPassword(context.Background(), "user@example.com")
 	if err == nil {
 		t.Fatal("ожидалась ошибка при сбое отправки")
 	}
 	u, _ := repo.GetUserByEmail(context.Background(), "user@example.com")
 	if u.PasswordHash != "old-hash" {
 		t.Error("пароль изменён, хотя письмо не ушло — аккаунт заблокирован")
 	}
 }
 func TestRefreshPasswordUnknownEmail(t *testing.T) {
 	repo := newFakeRepo()
 	sender := &fakeSender{}
 	svc := newTestService(repo, sender)
 	// Анти-enumeration: для несуществующего адреса — успех и без письма.
 	if err := svc.RefreshPassword(context.Background(), "nobody@example.com"); err != nil {
 		t.Fatalf("для несуществующего email ожидался успех, получено %v", err)
 	}
 	if len(sender.sent()) != 0 {
 		t.Error("письмо не должно уходить несуществующему пользователю")
 	}
 }
 func TestRefreshPasswordInvalidEmail(t *testing.T) {
 	repo := newFakeRepo()
 	sender := &fakeSender{}
 	svc := newTestService(repo, sender)
 	if err := svc.RefreshPassword(context.Background(), "not-an-email"); err == nil {
 		t.Fatal("ожидалась ошибка валидации email")
 	}
 	if len(sender.sent()) != 0 {
 		t.Error("письмо не должно уходить при невалидном email")
 	}
 }
@@ -6,13 +6,11 @@ CREATE TABLE
        status VARCHAR(50) DEFAULT 'register',
        creator_id INTEGER NOT NULL,
        game_id INTEGER NOT NULL,
        scenario_id INTEGER NOT NULL,
        password TEXT,
        created_at TIMESTAMP NOT NULL DEFAULT NOW (),
        CONSTRAINT fk_teams_game FOREIGN KEY (game_id) REFERENCES games (id) ON DELETE RESTRICT,
-        CONSTRAINT fk_teams_creator FOREIGN KEY (creator_id) REFERENCES users (id) ON DELETE RESTRICT,
+        CONSTRAINT fk_teams_creator FOREIGN KEY (creator_id) REFERENCES users (id) ON DELETE RESTRICT
        CONSTRAINT fk_teams_scenario FOREIGN KEY (scenario_id) REFERENCES scenarios (id) ON DELETE RESTRICT
    );
 -- +goose Down
@@ -1,14 +0,0 @@
 -- +goose Up
 CREATE TABLE
    IF NOT EXISTS links (
        id SERIAL PRIMARY KEY,
        team_id INTEGER,
        game_id INTEGER,
        created_at TIMESTAMP NOT NULL DEFAULT NOW (),
        CONSTRAINT fk_links_team FOREIGN KEY (team_id) REFERENCES teams (id) ON DELETE RESTRICT,
        CONSTRAINT fk_links_game FOREIGN KEY (game_id) REFERENCES games (id) ON DELETE RESTRICT
    );
 -- +goose Down
 DROP TABLE IF EXISTS links;
@@ -0,0 +1,13 @@
 -- +goose Up
 CREATE TABLE
    IF NOT EXISTS actions (
        id SERIAL PRIMARY KEY,
        code TEXT,
        team_id INTEGER,
        created_at TIMESTAMP NOT NULL DEFAULT NOW (),
        CONSTRAINT fk_actions_team FOREIGN KEY (team_id) REFERENCES teams (id) ON DELETE CASCADE
    );
 -- +goose Down
 DROP TABLE IF EXISTS actions;
@@ -0,0 +1,15 @@
 -- +goose Up
 CREATE TABLE
    IF NOT EXISTS applications (
        id SERIAL PRIMARY KEY,
        name TEXT,
        image TEXT,
        team_id INTEGER,
        status VARCHAR(50) DEFAULT 'need',
        created_at TIMESTAMP NOT NULL DEFAULT NOW (),
        CONSTRAINT fk_applications_team FOREIGN KEY (team_id) REFERENCES teams (id) ON DELETE CASCADE
    );
 -- +goose Down
 DROP TABLE IF EXISTS applications;
@@ -0,0 +1,26 @@
 -- +goose Up
 CREATE TABLE
    IF NOT EXISTS user_agreements (
        id SERIAL PRIMARY KEY,
        -- user_id NULL-able: при удалении аккаунта FK-ограничение обнуляет
        -- ссылку (ON DELETE SET NULL), а сама запись об акцепте остаётся в
        -- обезличенном виде (факт согласия, ст. 9 ч. 4 152-ФЗ — бремя
        -- доказывания на операторе). Персональные данные внутри записи
        -- (ip, user_agent) обнуляет users_repo.DeleteUser.
        user_id INTEGER,
        agreement_type VARCHAR(50) NOT NULL,
        version VARCHAR(50) NOT NULL,
        accepted_at TIMESTAMP NOT NULL DEFAULT NOW (),
        ip VARCHAR(45),
        user_agent TEXT,
        CONSTRAINT fk_user_agreements_user FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE SET NULL,
        CONSTRAINT uq_user_agreement UNIQUE (user_id, agreement_type, version),
        CONSTRAINT chk_user_agreement_type CHECK (agreement_type IN ('terms', 'privacy'))
    );
 -- Отдельный индекс по user_id не нужен: UNIQUE (user_id, agreement_type, version)
 -- уже покрывает выборки по префиксу user_id.
 -- +goose Down
 DROP TABLE IF EXISTS user_agreements;
@@ -0,0 +1,39 @@
 -- +goose Up
 -- Сценарии и команды сохраняются при удалении аккаунта автора:
 -- привязка к пользователю обнуляется (обезличивание, ст. 3 152-ФЗ),
 -- сам контент остаётся в Сервисе (лицензия по п. 7.2 Пользовательского соглашения).
 ALTER TABLE scenarios ALTER COLUMN author_id DROP NOT NULL;
 ALTER TABLE scenarios DROP CONSTRAINT IF EXISTS fk_scenarios_author;
 ALTER TABLE scenarios ADD CONSTRAINT fk_scenarios_author
    FOREIGN KEY (author_id) REFERENCES users (id) ON DELETE SET NULL;
 ALTER TABLE teams ALTER COLUMN creator_id DROP NOT NULL;
 ALTER TABLE teams DROP CONSTRAINT IF EXISTS fk_teams_creator;
 ALTER TABLE teams ADD CONSTRAINT fk_teams_creator
    FOREIGN KEY (creator_id) REFERENCES users (id) ON DELETE SET NULL;
 -- status у сценариев всегда задан (default 'draft'): NULL-значение сломало бы
 -- guard'ы вида "status <> 'public'" в scenarios_repo (NULL даёт NULL, т.е. ложь).
 -- На БД с историческими NULL-данными сначала приводим их к default'у.
 UPDATE scenarios SET status = 'draft' WHERE status IS NULL;
 ALTER TABLE scenarios ALTER COLUMN status SET NOT NULL;
 -- +goose Down
 -- Восстановление прежней схемы: автор обязателен, при удалении пользователя —
 -- удаление его контента запрещено (RESTRICT).
 DELETE FROM scenarios WHERE author_id IS NULL;
 DELETE FROM teams WHERE creator_id IS NULL;
 ALTER TABLE scenarios ALTER COLUMN status DROP NOT NULL;
 ALTER TABLE scenarios DROP CONSTRAINT IF EXISTS fk_scenarios_author;
 ALTER TABLE scenarios ADD CONSTRAINT fk_scenarios_author
    FOREIGN KEY (author_id) REFERENCES users (id) ON DELETE RESTRICT;
 ALTER TABLE scenarios ALTER COLUMN author_id SET NOT NULL;
 ALTER TABLE teams DROP CONSTRAINT IF EXISTS fk_teams_creator;
 ALTER TABLE teams ADD CONSTRAINT fk_teams_creator
    FOREIGN KEY (creator_id) REFERENCES users (id) ON DELETE RESTRICT;
 ALTER TABLE teams ALTER COLUMN creator_id SET NOT NULL;
@@ -26,6 +26,10 @@ const (
 	EveningDetectiveServer_RefreshPassword_FullMethodName         = "/crabs.evening_detective_server.EveningDetectiveServer/RefreshPassword"
 	EveningDetectiveServer_Login_FullMethodName                   = "/crabs.evening_detective_server.EveningDetectiveServer/Login"
 	EveningDetectiveServer_Refresh_FullMethodName                 = "/crabs.evening_detective_server.EveningDetectiveServer/Refresh"
 	EveningDetectiveServer_DeleteAccount_FullMethodName           = "/crabs.evening_detective_server.EveningDetectiveServer/DeleteAccount"
 	EveningDetectiveServer_GetTerms_FullMethodName                = "/crabs.evening_detective_server.EveningDetectiveServer/GetTerms"
 	EveningDetectiveServer_GetPrivacy_FullMethodName              = "/crabs.evening_detective_server.EveningDetectiveServer/GetPrivacy"
 	EveningDetectiveServer_GetConsent_FullMethodName              = "/crabs.evening_detective_server.EveningDetectiveServer/GetConsent"
 	EveningDetectiveServer_GetUsers_FullMethodName                = "/crabs.evening_detective_server.EveningDetectiveServer/GetUsers"
 	EveningDetectiveServer_GetUserById_FullMethodName             = "/crabs.evening_detective_server.EveningDetectiveServer/GetUserById"
 	EveningDetectiveServer_GetMe_FullMethodName                   = "/crabs.evening_detective_server.EveningDetectiveServer/GetMe"
@@ -46,17 +50,25 @@ const (
 	EveningDetectiveServer_AddScenarioPlace_FullMethodName        = "/crabs.evening_detective_server.EveningDetectiveServer/AddScenarioPlace"
 	EveningDetectiveServer_UpdateScenarioPlace_FullMethodName     = "/crabs.evening_detective_server.EveningDetectiveServer/UpdateScenarioPlace"
 	EveningDetectiveServer_DeleteScenarioPlace_FullMethodName     = "/crabs.evening_detective_server.EveningDetectiveServer/DeleteScenarioPlace"
 	EveningDetectiveServer_DownloadScenarioArchive_FullMethodName = "/crabs.evening_detective_server.EveningDetectiveServer/DownloadScenarioArchive"
 	EveningDetectiveServer_UploadScenarioArchive_FullMethodName   = "/crabs.evening_detective_server.EveningDetectiveServer/UploadScenarioArchive"
 	EveningDetectiveServer_AddGame_FullMethodName                 = "/crabs.evening_detective_server.EveningDetectiveServer/AddGame"
 	EveningDetectiveServer_GetGames_FullMethodName                = "/crabs.evening_detective_server.EveningDetectiveServer/GetGames"
 	EveningDetectiveServer_GetGame_FullMethodName                 = "/crabs.evening_detective_server.EveningDetectiveServer/GetGame"
 	EveningDetectiveServer_UpdateGame_FullMethodName              = "/crabs.evening_detective_server.EveningDetectiveServer/UpdateGame"
 	EveningDetectiveServer_StartGame_FullMethodName               = "/crabs.evening_detective_server.EveningDetectiveServer/StartGame"
 	EveningDetectiveServer_PauseGame_FullMethodName               = "/crabs.evening_detective_server.EveningDetectiveServer/PauseGame"
 	EveningDetectiveServer_PlayGame_FullMethodName                = "/crabs.evening_detective_server.EveningDetectiveServer/PlayGame"
 	EveningDetectiveServer_FinishGame_FullMethodName              = "/crabs.evening_detective_server.EveningDetectiveServer/FinishGame"
 	EveningDetectiveServer_ResetGame_FullMethodName               = "/crabs.evening_detective_server.EveningDetectiveServer/ResetGame"
 	EveningDetectiveServer_DeleteGame_FullMethodName              = "/crabs.evening_detective_server.EveningDetectiveServer/DeleteGame"
 	EveningDetectiveServer_AddTeam_FullMethodName                 = "/crabs.evening_detective_server.EveningDetectiveServer/AddTeam"
 	EveningDetectiveServer_UpdateTeam_FullMethodName              = "/crabs.evening_detective_server.EveningDetectiveServer/UpdateTeam"
 	EveningDetectiveServer_DeleteTeam_FullMethodName              = "/crabs.evening_detective_server.EveningDetectiveServer/DeleteTeam"
 	EveningDetectiveServer_GiveTeamApplications_FullMethodName    = "/crabs.evening_detective_server.EveningDetectiveServer/GiveTeamApplications"
-	EveningDetectiveServer_GetTeamActions_FullMethodName       = "/crabs.evening_detective_server.EveningDetectiveServer/GetTeamActions"
+	EveningDetectiveServer_GetTeamStory_FullMethodName            = "/crabs.evening_detective_server.EveningDetectiveServer/GetTeamStory"
 	EveningDetectiveServer_AddTeamAction_FullMethodName           = "/crabs.evening_detective_server.EveningDetectiveServer/AddTeamAction"
 	EveningDetectiveServer_DeleteLastTeamAction_FullMethodName    = "/crabs.evening_detective_server.EveningDetectiveServer/DeleteLastTeamAction"
 )
 // EveningDetectiveServerClient is the client API for EveningDetectiveServer service.
@@ -69,6 +81,10 @@ type EveningDetectiveServerClient interface {
 	RefreshPassword(ctx context.Context, in *RefreshPasswordReq, opts ...grpc.CallOption) (*RefreshPasswordRsp, error)
 	Login(ctx context.Context, in *LoginReq, opts ...grpc.CallOption) (*LoginRsp, error)
 	Refresh(ctx context.Context, in *RefreshReq, opts ...grpc.CallOption) (*RefreshRsp, error)
 	DeleteAccount(ctx context.Context, in *DeleteAccountReq, opts ...grpc.CallOption) (*DeleteAccountRsp, error)
 	GetTerms(ctx context.Context, in *GetTermsReq, opts ...grpc.CallOption) (*GetTermsRsp, error)
 	GetPrivacy(ctx context.Context, in *GetPrivacyReq, opts ...grpc.CallOption) (*GetPrivacyRsp, error)
 	GetConsent(ctx context.Context, in *GetConsentReq, opts ...grpc.CallOption) (*GetConsentRsp, error)
 	GetUsers(ctx context.Context, in *GetUsersReq, opts ...grpc.CallOption) (*GetUsersRsp, error)
 	GetUserById(ctx context.Context, in *GetUserByIdReq, opts ...grpc.CallOption) (*GetUserByIdRsp, error)
 	GetMe(ctx context.Context, in *GetMeReq, opts ...grpc.CallOption) (*GetMeRsp, error)
@@ -89,17 +105,25 @@ type EveningDetectiveServerClient interface {
 	AddScenarioPlace(ctx context.Context, in *AddScenarioPlaceReq, opts ...grpc.CallOption) (*AddScenarioPlaceRsp, error)
 	UpdateScenarioPlace(ctx context.Context, in *UpdateScenarioPlaceReq, opts ...grpc.CallOption) (*UpdateScenarioPlaceRsp, error)
 	DeleteScenarioPlace(ctx context.Context, in *DeleteScenarioPlaceReq, opts ...grpc.CallOption) (*DeleteScenarioPlaceRsp, error)
 	DownloadScenarioArchive(ctx context.Context, in *DownloadScenarioArchiveReq, opts ...grpc.CallOption) (*httpbody.HttpBody, error)
 	UploadScenarioArchive(ctx context.Context, in *httpbody.HttpBody, opts ...grpc.CallOption) (*UploadScenarioArchiveRsp, error)
 	AddGame(ctx context.Context, in *AddGameReq, opts ...grpc.CallOption) (*AddGameRsp, error)
 	GetGames(ctx context.Context, in *GetGamesReq, opts ...grpc.CallOption) (*GetGamesRsp, error)
 	GetGame(ctx context.Context, in *GetGameReq, opts ...grpc.CallOption) (*GetGameRsp, error)
 	UpdateGame(ctx context.Context, in *UpdateGameReq, opts ...grpc.CallOption) (*UpdateGameRsp, error)
 	StartGame(ctx context.Context, in *StartGameReq, opts ...grpc.CallOption) (*StartGameRsp, error)
 	PauseGame(ctx context.Context, in *PauseGameReq, opts ...grpc.CallOption) (*PauseGameRsp, error)
 	PlayGame(ctx context.Context, in *PlayGameReq, opts ...grpc.CallOption) (*PlayGameRsp, error)
 	FinishGame(ctx context.Context, in *FinishGameReq, opts ...grpc.CallOption) (*FinishGameRsp, error)
 	ResetGame(ctx context.Context, in *ResetGameReq, opts ...grpc.CallOption) (*ResetGameRsp, error)
 	DeleteGame(ctx context.Context, in *DeleteGameReq, opts ...grpc.CallOption) (*DeleteGameRsp, error)
 	AddTeam(ctx context.Context, in *AddTeamReq, opts ...grpc.CallOption) (*AddTeamRsp, error)
 	UpdateTeam(ctx context.Context, in *UpdateTeamReq, opts ...grpc.CallOption) (*UpdateTeamRsp, error)
 	DeleteTeam(ctx context.Context, in *DeleteTeamReq, opts ...grpc.CallOption) (*DeleteTeamRsp, error)
 	GiveTeamApplications(ctx context.Context, in *GiveTeamApplicationsReq, opts ...grpc.CallOption) (*GiveTeamApplicationsRsp, error)
-	GetTeamActions(ctx context.Context, in *GetTeamActionsReq, opts ...grpc.CallOption) (*GetTeamActionsRsp, error)
+	GetTeamStory(ctx context.Context, in *GetTeamStoryReq, opts ...grpc.CallOption) (*GetTeamStoryRsp, error)
 	AddTeamAction(ctx context.Context, in *AddTeamActionReq, opts ...grpc.CallOption) (*AddTeamActionRsp, error)
 	DeleteLastTeamAction(ctx context.Context, in *DeleteLastTeamActionReq, opts ...grpc.CallOption) (*DeleteLastTeamActionRsp, error)
 }
 type eveningDetectiveServerClient struct {
@@ -170,6 +194,46 @@ func (c *eveningDetectiveServerClient) Refresh(ctx context.Context, in *RefreshR
 	return out, nil
 }
 func (c *eveningDetectiveServerClient) DeleteAccount(ctx context.Context, in *DeleteAccountReq, opts ...grpc.CallOption) (*DeleteAccountRsp, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(DeleteAccountRsp)
 	err := c.cc.Invoke(ctx, EveningDetectiveServer_DeleteAccount_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 func (c *eveningDetectiveServerClient) GetTerms(ctx context.Context, in *GetTermsReq, opts ...grpc.CallOption) (*GetTermsRsp, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(GetTermsRsp)
 	err := c.cc.Invoke(ctx, EveningDetectiveServer_GetTerms_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 func (c *eveningDetectiveServerClient) GetPrivacy(ctx context.Context, in *GetPrivacyReq, opts ...grpc.CallOption) (*GetPrivacyRsp, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(GetPrivacyRsp)
 	err := c.cc.Invoke(ctx, EveningDetectiveServer_GetPrivacy_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 func (c *eveningDetectiveServerClient) GetConsent(ctx context.Context, in *GetConsentReq, opts ...grpc.CallOption) (*GetConsentRsp, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(GetConsentRsp)
 	err := c.cc.Invoke(ctx, EveningDetectiveServer_GetConsent_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 func (c *eveningDetectiveServerClient) GetUsers(ctx context.Context, in *GetUsersReq, opts ...grpc.CallOption) (*GetUsersRsp, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(GetUsersRsp)
@@ -370,6 +434,26 @@ func (c *eveningDetectiveServerClient) DeleteScenarioPlace(ctx context.Context,
 	return out, nil
 }
 func (c *eveningDetectiveServerClient) DownloadScenarioArchive(ctx context.Context, in *DownloadScenarioArchiveReq, opts ...grpc.CallOption) (*httpbody.HttpBody, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(httpbody.HttpBody)
 	err := c.cc.Invoke(ctx, EveningDetectiveServer_DownloadScenarioArchive_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 func (c *eveningDetectiveServerClient) UploadScenarioArchive(ctx context.Context, in *httpbody.HttpBody, opts ...grpc.CallOption) (*UploadScenarioArchiveRsp, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(UploadScenarioArchiveRsp)
 	err := c.cc.Invoke(ctx, EveningDetectiveServer_UploadScenarioArchive_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 func (c *eveningDetectiveServerClient) AddGame(ctx context.Context, in *AddGameReq, opts ...grpc.CallOption) (*AddGameRsp, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(AddGameRsp)
@@ -410,6 +494,56 @@ func (c *eveningDetectiveServerClient) UpdateGame(ctx context.Context, in *Updat
 	return out, nil
 }
 func (c *eveningDetectiveServerClient) StartGame(ctx context.Context, in *StartGameReq, opts ...grpc.CallOption) (*StartGameRsp, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(StartGameRsp)
 	err := c.cc.Invoke(ctx, EveningDetectiveServer_StartGame_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 func (c *eveningDetectiveServerClient) PauseGame(ctx context.Context, in *PauseGameReq, opts ...grpc.CallOption) (*PauseGameRsp, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(PauseGameRsp)
 	err := c.cc.Invoke(ctx, EveningDetectiveServer_PauseGame_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 func (c *eveningDetectiveServerClient) PlayGame(ctx context.Context, in *PlayGameReq, opts ...grpc.CallOption) (*PlayGameRsp, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(PlayGameRsp)
 	err := c.cc.Invoke(ctx, EveningDetectiveServer_PlayGame_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 func (c *eveningDetectiveServerClient) FinishGame(ctx context.Context, in *FinishGameReq, opts ...grpc.CallOption) (*FinishGameRsp, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(FinishGameRsp)
 	err := c.cc.Invoke(ctx, EveningDetectiveServer_FinishGame_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 func (c *eveningDetectiveServerClient) ResetGame(ctx context.Context, in *ResetGameReq, opts ...grpc.CallOption) (*ResetGameRsp, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(ResetGameRsp)
 	err := c.cc.Invoke(ctx, EveningDetectiveServer_ResetGame_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 func (c *eveningDetectiveServerClient) DeleteGame(ctx context.Context, in *DeleteGameReq, opts ...grpc.CallOption) (*DeleteGameRsp, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(DeleteGameRsp)
@@ -460,10 +594,10 @@ func (c *eveningDetectiveServerClient) GiveTeamApplications(ctx context.Context,
 	return out, nil
 }
-func (c *eveningDetectiveServerClient) GetTeamActions(ctx context.Context, in *GetTeamActionsReq, opts ...grpc.CallOption) (*GetTeamActionsRsp, error) {
+func (c *eveningDetectiveServerClient) GetTeamStory(ctx context.Context, in *GetTeamStoryReq, opts ...grpc.CallOption) (*GetTeamStoryRsp, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
-	out := new(GetTeamActionsRsp)
+	out := new(GetTeamStoryRsp)
-	err := c.cc.Invoke(ctx, EveningDetectiveServer_GetTeamActions_FullMethodName, in, out, cOpts...)
+	err := c.cc.Invoke(ctx, EveningDetectiveServer_GetTeamStory_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -480,6 +614,16 @@ func (c *eveningDetectiveServerClient) AddTeamAction(ctx context.Context, in *Ad
 	return out, nil
 }
 func (c *eveningDetectiveServerClient) DeleteLastTeamAction(ctx context.Context, in *DeleteLastTeamActionReq, opts ...grpc.CallOption) (*DeleteLastTeamActionRsp, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(DeleteLastTeamActionRsp)
 	err := c.cc.Invoke(ctx, EveningDetectiveServer_DeleteLastTeamAction_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 // EveningDetectiveServerServer is the server API for EveningDetectiveServer service.
 // All implementations must embed UnimplementedEveningDetectiveServerServer
 // for forward compatibility.
@@ -490,6 +634,10 @@ type EveningDetectiveServerServer interface {
 	RefreshPassword(context.Context, *RefreshPasswordReq) (*RefreshPasswordRsp, error)
 	Login(context.Context, *LoginReq) (*LoginRsp, error)
 	Refresh(context.Context, *RefreshReq) (*RefreshRsp, error)
 	DeleteAccount(context.Context, *DeleteAccountReq) (*DeleteAccountRsp, error)
 	GetTerms(context.Context, *GetTermsReq) (*GetTermsRsp, error)
 	GetPrivacy(context.Context, *GetPrivacyReq) (*GetPrivacyRsp, error)
 	GetConsent(context.Context, *GetConsentReq) (*GetConsentRsp, error)
 	GetUsers(context.Context, *GetUsersReq) (*GetUsersRsp, error)
 	GetUserById(context.Context, *GetUserByIdReq) (*GetUserByIdRsp, error)
 	GetMe(context.Context, *GetMeReq) (*GetMeRsp, error)
@@ -510,17 +658,25 @@ type EveningDetectiveServerServer interface {
 	AddScenarioPlace(context.Context, *AddScenarioPlaceReq) (*AddScenarioPlaceRsp, error)
 	UpdateScenarioPlace(context.Context, *UpdateScenarioPlaceReq) (*UpdateScenarioPlaceRsp, error)
 	DeleteScenarioPlace(context.Context, *DeleteScenarioPlaceReq) (*DeleteScenarioPlaceRsp, error)
 	DownloadScenarioArchive(context.Context, *DownloadScenarioArchiveReq) (*httpbody.HttpBody, error)
 	UploadScenarioArchive(context.Context, *httpbody.HttpBody) (*UploadScenarioArchiveRsp, error)
 	AddGame(context.Context, *AddGameReq) (*AddGameRsp, error)
 	GetGames(context.Context, *GetGamesReq) (*GetGamesRsp, error)
 	GetGame(context.Context, *GetGameReq) (*GetGameRsp, error)
 	UpdateGame(context.Context, *UpdateGameReq) (*UpdateGameRsp, error)
 	StartGame(context.Context, *StartGameReq) (*StartGameRsp, error)
 	PauseGame(context.Context, *PauseGameReq) (*PauseGameRsp, error)
 	PlayGame(context.Context, *PlayGameReq) (*PlayGameRsp, error)
 	FinishGame(context.Context, *FinishGameReq) (*FinishGameRsp, error)
 	ResetGame(context.Context, *ResetGameReq) (*ResetGameRsp, error)
 	DeleteGame(context.Context, *DeleteGameReq) (*DeleteGameRsp, error)
 	AddTeam(context.Context, *AddTeamReq) (*AddTeamRsp, error)
 	UpdateTeam(context.Context, *UpdateTeamReq) (*UpdateTeamRsp, error)
 	DeleteTeam(context.Context, *DeleteTeamReq) (*DeleteTeamRsp, error)
 	GiveTeamApplications(context.Context, *GiveTeamApplicationsReq) (*GiveTeamApplicationsRsp, error)
-	GetTeamActions(context.Context, *GetTeamActionsReq) (*GetTeamActionsRsp, error)
+	GetTeamStory(context.Context, *GetTeamStoryReq) (*GetTeamStoryRsp, error)
 	AddTeamAction(context.Context, *AddTeamActionReq) (*AddTeamActionRsp, error)
 	DeleteLastTeamAction(context.Context, *DeleteLastTeamActionReq) (*DeleteLastTeamActionRsp, error)
 	mustEmbedUnimplementedEveningDetectiveServerServer()
 }
@@ -549,6 +705,18 @@ func (UnimplementedEveningDetectiveServerServer) Login(context.Context, *LoginRe
 func (UnimplementedEveningDetectiveServerServer) Refresh(context.Context, *RefreshReq) (*RefreshRsp, error) {
 	return nil, status.Error(codes.Unimplemented, "method Refresh not implemented")
 }
 func (UnimplementedEveningDetectiveServerServer) DeleteAccount(context.Context, *DeleteAccountReq) (*DeleteAccountRsp, error) {
 	return nil, status.Error(codes.Unimplemented, "method DeleteAccount not implemented")
 }
 func (UnimplementedEveningDetectiveServerServer) GetTerms(context.Context, *GetTermsReq) (*GetTermsRsp, error) {
 	return nil, status.Error(codes.Unimplemented, "method GetTerms not implemented")
 }
 func (UnimplementedEveningDetectiveServerServer) GetPrivacy(context.Context, *GetPrivacyReq) (*GetPrivacyRsp, error) {
 	return nil, status.Error(codes.Unimplemented, "method GetPrivacy not implemented")
 }
 func (UnimplementedEveningDetectiveServerServer) GetConsent(context.Context, *GetConsentReq) (*GetConsentRsp, error) {
 	return nil, status.Error(codes.Unimplemented, "method GetConsent not implemented")
 }
 func (UnimplementedEveningDetectiveServerServer) GetUsers(context.Context, *GetUsersReq) (*GetUsersRsp, error) {
 	return nil, status.Error(codes.Unimplemented, "method GetUsers not implemented")
 }
@@ -609,6 +777,12 @@ func (UnimplementedEveningDetectiveServerServer) UpdateScenarioPlace(context.Con
 func (UnimplementedEveningDetectiveServerServer) DeleteScenarioPlace(context.Context, *DeleteScenarioPlaceReq) (*DeleteScenarioPlaceRsp, error) {
 	return nil, status.Error(codes.Unimplemented, "method DeleteScenarioPlace not implemented")
 }
 func (UnimplementedEveningDetectiveServerServer) DownloadScenarioArchive(context.Context, *DownloadScenarioArchiveReq) (*httpbody.HttpBody, error) {
 	return nil, status.Error(codes.Unimplemented, "method DownloadScenarioArchive not implemented")
 }
 func (UnimplementedEveningDetectiveServerServer) UploadScenarioArchive(context.Context, *httpbody.HttpBody) (*UploadScenarioArchiveRsp, error) {
 	return nil, status.Error(codes.Unimplemented, "method UploadScenarioArchive not implemented")
 }
 func (UnimplementedEveningDetectiveServerServer) AddGame(context.Context, *AddGameReq) (*AddGameRsp, error) {
 	return nil, status.Error(codes.Unimplemented, "method AddGame not implemented")
 }
@@ -621,6 +795,21 @@ func (UnimplementedEveningDetectiveServerServer) GetGame(context.Context, *GetGa
 func (UnimplementedEveningDetectiveServerServer) UpdateGame(context.Context, *UpdateGameReq) (*UpdateGameRsp, error) {
 	return nil, status.Error(codes.Unimplemented, "method UpdateGame not implemented")
 }
 func (UnimplementedEveningDetectiveServerServer) StartGame(context.Context, *StartGameReq) (*StartGameRsp, error) {
 	return nil, status.Error(codes.Unimplemented, "method StartGame not implemented")
 }
 func (UnimplementedEveningDetectiveServerServer) PauseGame(context.Context, *PauseGameReq) (*PauseGameRsp, error) {
 	return nil, status.Error(codes.Unimplemented, "method PauseGame not implemented")
 }
 func (UnimplementedEveningDetectiveServerServer) PlayGame(context.Context, *PlayGameReq) (*PlayGameRsp, error) {
 	return nil, status.Error(codes.Unimplemented, "method PlayGame not implemented")
 }
 func (UnimplementedEveningDetectiveServerServer) FinishGame(context.Context, *FinishGameReq) (*FinishGameRsp, error) {
 	return nil, status.Error(codes.Unimplemented, "method FinishGame not implemented")
 }
 func (UnimplementedEveningDetectiveServerServer) ResetGame(context.Context, *ResetGameReq) (*ResetGameRsp, error) {
 	return nil, status.Error(codes.Unimplemented, "method ResetGame not implemented")
 }
 func (UnimplementedEveningDetectiveServerServer) DeleteGame(context.Context, *DeleteGameReq) (*DeleteGameRsp, error) {
 	return nil, status.Error(codes.Unimplemented, "method DeleteGame not implemented")
 }
@@ -636,12 +825,15 @@ func (UnimplementedEveningDetectiveServerServer) DeleteTeam(context.Context, *De
 func (UnimplementedEveningDetectiveServerServer) GiveTeamApplications(context.Context, *GiveTeamApplicationsReq) (*GiveTeamApplicationsRsp, error) {
 	return nil, status.Error(codes.Unimplemented, "method GiveTeamApplications not implemented")
 }
-func (UnimplementedEveningDetectiveServerServer) GetTeamActions(context.Context, *GetTeamActionsReq) (*GetTeamActionsRsp, error) {
+func (UnimplementedEveningDetectiveServerServer) GetTeamStory(context.Context, *GetTeamStoryReq) (*GetTeamStoryRsp, error) {
-	return nil, status.Error(codes.Unimplemented, "method GetTeamActions not implemented")
+	return nil, status.Error(codes.Unimplemented, "method GetTeamStory not implemented")
 }
 func (UnimplementedEveningDetectiveServerServer) AddTeamAction(context.Context, *AddTeamActionReq) (*AddTeamActionRsp, error) {
 	return nil, status.Error(codes.Unimplemented, "method AddTeamAction not implemented")
 }
 func (UnimplementedEveningDetectiveServerServer) DeleteLastTeamAction(context.Context, *DeleteLastTeamActionReq) (*DeleteLastTeamActionRsp, error) {
 	return nil, status.Error(codes.Unimplemented, "method DeleteLastTeamAction not implemented")
 }
 func (UnimplementedEveningDetectiveServerServer) mustEmbedUnimplementedEveningDetectiveServerServer() {
 }
 func (UnimplementedEveningDetectiveServerServer) testEmbeddedByValue() {}
@@ -772,6 +964,78 @@ func _EveningDetectiveServer_Refresh_Handler(srv interface{}, ctx context.Contex
 	return interceptor(ctx, in, info, handler)
 }
 func _EveningDetectiveServer_DeleteAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(DeleteAccountReq)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
 		return srv.(EveningDetectiveServerServer).DeleteAccount(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
 		FullMethod: EveningDetectiveServer_DeleteAccount_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(EveningDetectiveServerServer).DeleteAccount(ctx, req.(*DeleteAccountReq))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 func _EveningDetectiveServer_GetTerms_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(GetTermsReq)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
 		return srv.(EveningDetectiveServerServer).GetTerms(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
 		FullMethod: EveningDetectiveServer_GetTerms_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(EveningDetectiveServerServer).GetTerms(ctx, req.(*GetTermsReq))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 func _EveningDetectiveServer_GetPrivacy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(GetPrivacyReq)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
 		return srv.(EveningDetectiveServerServer).GetPrivacy(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
 		FullMethod: EveningDetectiveServer_GetPrivacy_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(EveningDetectiveServerServer).GetPrivacy(ctx, req.(*GetPrivacyReq))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 func _EveningDetectiveServer_GetConsent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(GetConsentReq)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
 		return srv.(EveningDetectiveServerServer).GetConsent(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
 		FullMethod: EveningDetectiveServer_GetConsent_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(EveningDetectiveServerServer).GetConsent(ctx, req.(*GetConsentReq))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 func _EveningDetectiveServer_GetUsers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(GetUsersReq)
 	if err := dec(in); err != nil {
@@ -1132,6 +1396,42 @@ func _EveningDetectiveServer_DeleteScenarioPlace_Handler(srv interface{}, ctx co
 	return interceptor(ctx, in, info, handler)
 }
 func _EveningDetectiveServer_DownloadScenarioArchive_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(DownloadScenarioArchiveReq)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
 		return srv.(EveningDetectiveServerServer).DownloadScenarioArchive(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
 		FullMethod: EveningDetectiveServer_DownloadScenarioArchive_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(EveningDetectiveServerServer).DownloadScenarioArchive(ctx, req.(*DownloadScenarioArchiveReq))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 func _EveningDetectiveServer_UploadScenarioArchive_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(httpbody.HttpBody)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
 		return srv.(EveningDetectiveServerServer).UploadScenarioArchive(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
 		FullMethod: EveningDetectiveServer_UploadScenarioArchive_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(EveningDetectiveServerServer).UploadScenarioArchive(ctx, req.(*httpbody.HttpBody))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 func _EveningDetectiveServer_AddGame_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(AddGameReq)
 	if err := dec(in); err != nil {
@@ -1204,6 +1504,96 @@ func _EveningDetectiveServer_UpdateGame_Handler(srv interface{}, ctx context.Con
 	return interceptor(ctx, in, info, handler)
 }
 func _EveningDetectiveServer_StartGame_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(StartGameReq)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
 		return srv.(EveningDetectiveServerServer).StartGame(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
 		FullMethod: EveningDetectiveServer_StartGame_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(EveningDetectiveServerServer).StartGame(ctx, req.(*StartGameReq))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 func _EveningDetectiveServer_PauseGame_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(PauseGameReq)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
 		return srv.(EveningDetectiveServerServer).PauseGame(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
 		FullMethod: EveningDetectiveServer_PauseGame_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(EveningDetectiveServerServer).PauseGame(ctx, req.(*PauseGameReq))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 func _EveningDetectiveServer_PlayGame_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(PlayGameReq)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
 		return srv.(EveningDetectiveServerServer).PlayGame(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
 		FullMethod: EveningDetectiveServer_PlayGame_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(EveningDetectiveServerServer).PlayGame(ctx, req.(*PlayGameReq))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 func _EveningDetectiveServer_FinishGame_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(FinishGameReq)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
 		return srv.(EveningDetectiveServerServer).FinishGame(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
 		FullMethod: EveningDetectiveServer_FinishGame_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(EveningDetectiveServerServer).FinishGame(ctx, req.(*FinishGameReq))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 func _EveningDetectiveServer_ResetGame_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(ResetGameReq)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
 		return srv.(EveningDetectiveServerServer).ResetGame(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
 		FullMethod: EveningDetectiveServer_ResetGame_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(EveningDetectiveServerServer).ResetGame(ctx, req.(*ResetGameReq))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 func _EveningDetectiveServer_DeleteGame_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(DeleteGameReq)
 	if err := dec(in); err != nil {
@@ -1294,20 +1684,20 @@ func _EveningDetectiveServer_GiveTeamApplications_Handler(srv interface{}, ctx c
 	return interceptor(ctx, in, info, handler)
 }
-func _EveningDetectiveServer_GetTeamActions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+func _EveningDetectiveServer_GetTeamStory_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(GetTeamActionsReq)
+	in := new(GetTeamStoryReq)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(EveningDetectiveServerServer).GetTeamActions(ctx, in)
+		return srv.(EveningDetectiveServerServer).GetTeamStory(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: EveningDetectiveServer_GetTeamActions_FullMethodName,
+		FullMethod: EveningDetectiveServer_GetTeamStory_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(EveningDetectiveServerServer).GetTeamActions(ctx, req.(*GetTeamActionsReq))
+		return srv.(EveningDetectiveServerServer).GetTeamStory(ctx, req.(*GetTeamStoryReq))
 	}
 	return interceptor(ctx, in, info, handler)
 }
@@ -1330,6 +1720,24 @@ func _EveningDetectiveServer_AddTeamAction_Handler(srv interface{}, ctx context.
 	return interceptor(ctx, in, info, handler)
 }
 func _EveningDetectiveServer_DeleteLastTeamAction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(DeleteLastTeamActionReq)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
 		return srv.(EveningDetectiveServerServer).DeleteLastTeamAction(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
 		FullMethod: EveningDetectiveServer_DeleteLastTeamAction_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(EveningDetectiveServerServer).DeleteLastTeamAction(ctx, req.(*DeleteLastTeamActionReq))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 // EveningDetectiveServer_ServiceDesc is the grpc.ServiceDesc for EveningDetectiveServer service.
 // It's only intended for direct use with grpc.RegisterService,
 // and not to be introspected or modified (even as a copy)
@@ -1361,6 +1769,22 @@ var EveningDetectiveServer_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "Refresh",
 			Handler:    _EveningDetectiveServer_Refresh_Handler,
 		},
 		{
 			MethodName: "DeleteAccount",
 			Handler:    _EveningDetectiveServer_DeleteAccount_Handler,
 		},
 		{
 			MethodName: "GetTerms",
 			Handler:    _EveningDetectiveServer_GetTerms_Handler,
 		},
 		{
 			MethodName: "GetPrivacy",
 			Handler:    _EveningDetectiveServer_GetPrivacy_Handler,
 		},
 		{
 			MethodName: "GetConsent",
 			Handler:    _EveningDetectiveServer_GetConsent_Handler,
 		},
 		{
 			MethodName: "GetUsers",
 			Handler:    _EveningDetectiveServer_GetUsers_Handler,
@@ -1441,6 +1865,14 @@ var EveningDetectiveServer_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "DeleteScenarioPlace",
 			Handler:    _EveningDetectiveServer_DeleteScenarioPlace_Handler,
 		},
 		{
 			MethodName: "DownloadScenarioArchive",
 			Handler:    _EveningDetectiveServer_DownloadScenarioArchive_Handler,
 		},
 		{
 			MethodName: "UploadScenarioArchive",
 			Handler:    _EveningDetectiveServer_UploadScenarioArchive_Handler,
 		},
 		{
 			MethodName: "AddGame",
 			Handler:    _EveningDetectiveServer_AddGame_Handler,
@@ -1457,6 +1889,26 @@ var EveningDetectiveServer_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "UpdateGame",
 			Handler:    _EveningDetectiveServer_UpdateGame_Handler,
 		},
 		{
 			MethodName: "StartGame",
 			Handler:    _EveningDetectiveServer_StartGame_Handler,
 		},
 		{
 			MethodName: "PauseGame",
 			Handler:    _EveningDetectiveServer_PauseGame_Handler,
 		},
 		{
 			MethodName: "PlayGame",
 			Handler:    _EveningDetectiveServer_PlayGame_Handler,
 		},
 		{
 			MethodName: "FinishGame",
 			Handler:    _EveningDetectiveServer_FinishGame_Handler,
 		},
 		{
 			MethodName: "ResetGame",
 			Handler:    _EveningDetectiveServer_ResetGame_Handler,
 		},
 		{
 			MethodName: "DeleteGame",
 			Handler:    _EveningDetectiveServer_DeleteGame_Handler,
@@ -1478,13 +1930,17 @@ var EveningDetectiveServer_ServiceDesc = grpc.ServiceDesc{
 			Handler:    _EveningDetectiveServer_GiveTeamApplications_Handler,
 		},
 		{
-			MethodName: "GetTeamActions",
+			MethodName: "GetTeamStory",
-			Handler:    _EveningDetectiveServer_GetTeamActions_Handler,
+			Handler:    _EveningDetectiveServer_GetTeamStory_Handler,
 		},
 		{
 			MethodName: "AddTeamAction",
 			Handler:    _EveningDetectiveServer_AddTeamAction_Handler,
 		},
 		{
 			MethodName: "DeleteLastTeamAction",
 			Handler:    _EveningDetectiveServer_DeleteLastTeamAction_Handler,
 		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "main.proto",
Author	SHA1	Message	Date
VLADIMIR	bafe22a95d	add skill	2026-08-21 23:03:44 +07:00
VLADIMIR	a2cadf6eca	clear	2026-08-21 00:09:32 +07:00
VLADIMIR	7656100fe6	add zip	2026-08-20 23:17:52 +07:00
VLADIMIR	6d37610348	update mail	2026-08-20 03:27:26 +07:00
VLADIMIR	4ff43cc2dd	updates email	2026-08-20 02:31:14 +07:00
VLADIMIR	be15264764	build	2026-08-20 00:17:30 +07:00
VLADIMIR	a797893a29	Merge pull request 'add docs' (#1 ) from add_docs into master Reviewed-on: #1	2026-08-19 17:15:26 +00:00
VLADIMIR	268b359576	fix urls	2026-08-19 23:31:37 +07:00
VLADIMIR	204a20c814	add docs	2026-08-19 02:15:57 +07:00
VLADIMIR	72605a3cd4	add юрист	2026-08-18 23:05:48 +07:00
VLADIMIR	e424174e29	add play	2026-08-04 01:36:52 +07:00
VLADIMIR	ff26c2e6bb	fix	2026-08-04 01:29:54 +07:00
VLADIMIR	a9bcb8598d	try fix	2026-08-04 01:25:35 +07:00
VLADIMIR	f3ac19ed83	add times to get game	2026-08-04 01:23:01 +07:00
VLADIMIR	ae3a8c809f	add game statuses	2026-08-04 00:46:33 +07:00
VLADIMIR	2492910e01	fix	2026-08-03 02:07:51 +07:00
VLADIMIR	599c73bc08	add game to team story	2026-08-03 01:17:50 +07:00
VLADIMIR	051b3e8bee	clear	2026-08-03 00:49:27 +07:00
VLADIMIR	c32a11d124	fix applications	2026-08-01 01:49:58 +07:00
VLADIMIR	1291a71a1a	fix codes	2026-07-29 19:40:46 +07:00
VLADIMIR	a227b80896	fix	2026-07-29 02:13:06 +07:00
VLADIMIR	33d0fb526f	clean links	2026-07-29 02:09:00 +07:00
VLADIMIR	d1b263fa78	fix add team	2026-07-29 00:59:37 +07:00
VLADIMIR	1b3e0b768d	fix codes	2026-07-28 23:21:27 +07:00
VLADIMIR	11798bd4fa	fix codes	2026-07-28 23:19:48 +07:00
VLADIMIR	cb1f31480c	update permissions	2026-07-28 22:40:32 +07:00
VLADIMIR	02b8014d08	add build	2026-07-28 22:01:53 +07:00
VLADIMIR	7aa8a50e30	add last action delete	2026-07-28 22:00:00 +07:00
VLADIMIR	5e3584e31a	update gave application	2026-07-28 21:30:28 +07:00
VLADIMIR	20662dc9da	add game	2026-07-28 20:38:03 +07:00
VLADIMIR	f6934e9d5b	add teams operations	2026-07-28 00:51:25 +07:00
VLADIMIR	5a5b36e44d	add delete last action	2026-07-28 00:09:29 +07:00
VLADIMIR	65763a3e10	add games	2026-07-28 00:02:11 +07:00
		`@@ -0,0 +1,2 @@`
							`name: Юрист по ПО`
							`description: Агент-консультант по правовым вопросам разработки ПО — лицензии (MIT, GPL, Apache...), авторские права, персональные данные (152-ФЗ/GDPR), договоры. Отвечает на основе встроенной базы знаний, без внешних API.`