feat(ui): каждая вкладка chat — независимая LLM-сессия

- ui.Session (UserID/Address/Title/BoundTask) + фабрики NewFreeSession/NewTaskSession и префикс ui://sess-*
- свободная вкладка без задачи: свой UserID, диалог с LLM в памяти (agent=chat, resume по sessionID)
- /start в свободной вкладке создаёт задачу с ChatID == UserID вкладки -> вкладка становится task-сессией
- desktop окно: container.AppTabs с вкладками, кнопка «Новый чат», маршрутизация Send/Ask/истории по Address вкладки
- app.FreeChat: in-memory связка uid -> opencode sessionID; роутинг свободного чата в handleIncoming
- агент chat.md + регистрация 'chat' в agents.Names
- тесты: session_test.go (фабрики/хелперы)

.serena/memories/conventions.md

@@ -1,10 +1,12 @@
 # conventions
 
 ## Стиль / кодстайл
-- Стандартный Go-стиль; гофм `gofmt`/`go fmt ./...`. Документация-комментарии и
+- Стандартный Go-стиль; `gofmt`/`go fmt ./...`. Документация-комментарии и
-  package-doc на русском языке (в START-комментариях файлов и doc-комментариях).
+  package-doc на русском языке.
-- Типизация: строгие типы, интерфейсы для абстракций (Decider, LiveProber).
+- Типизация: строгие типы, интерфейсы для абстракций (Decider, ui.Store, events.Event, chat.Channel).
 - Свой тип `config.Duration` для времени (YAML-строки "5s"/"10m"), метод `.Duration()`.
+- UI: uni-directional data flow — UI читает снапшоты (копии, `ui.Store`), не мутирует storage/core.
+  Ядро публикует события в `events.Bus`, UI подписывается `events.Hub` → колбэки в UI-поток через `fyne.Do`.
 
 ## Обработка ошибок
 - Ошибки классифицируются по идентификаторам классов в исходниках (см. ниже).
@@ -15,9 +17,10 @@
 | Блок | Коды | Где |
 |---|---|---|
 | C  | C1–C4 | internal/config |
-| A  | A1–A4 | internal/analyst |
+| A  | A1–A4 | internal/analyst; A (app): A1–A4 в internal/app |
 | M  | M1–M5 | internal/chat |
-| O  | O1–O4 | internal/opencode |
+| D  | D1–D5 | internal/core (ErrDecideFailed, ErrMaxTurns, ErrCommandUnknown…) |
+| O  | O1–O5 | internal/opencode |
 | S  | S1–S5 | internal/storage |
 | W  | W1–W5 | internal/worker |
 | E  | E1–E4 | internal/worker (репозитории) |
@@ -25,15 +28,16 @@
 | U  | U1–U6 | internal/update |
 
 ## Архитектурные конвенции
-- **Composition root** — internal/app; подсистемы собираются там, лимиты Core
+- **Composition root** — internal/app; подсистемы собираются там. UI-окно создаётся через
-  (MaxTurns=15, MaxConfirmCycles=3, MaxQuestionsPerTurn=5) в core.New.
+  `newUIWindow(store)` (build-tag: cgo → desktop.New, !cgo → nil/headless). Флаг `--noui` выключает окно.
-- **Агенты** (analyst.md/dev.md/reviewer.md) — markdown-промпты, встроены через go:embed
+- **Слои:** model (домен) ← storage/events/UI зависят только от model; core не знает про UI.
-  (internal/agents/*.md + embed.go), распаковываются в config_dir. Вердикт — строгий JSON.
+- **Агенты** (analyst.md/dev.md/reviewer.md) — markdown-промпты, go:embed, распаковка в config_dir.
+  Вердикт — строгий JSON.
 - Репо-клонирование/воркеры — через gitops; ветки задач `feat/<taskTag>` (см. mem:core).
 - Обратная совместимость: поле `Repo` (одиночный) и `Repos` (список); EffectiveRepos/
   SetReposFromDB/ReposJoined в storage/models.go.
 
 ## Версии
 - `app.Version` — семантическая major.minor.patch (ручной инкремент: patch=фиксы,
-  minor=новая обратно-совместимая функциональность, major=несовместимые изменения).
+  minor=новая обратно-совместимая функциональность, major=несовместимые изменения). Сейчас 0.2.2.
 - `main.version` (ldflag) — build-идентификатор `commit-<sha7>`, отдельно от app.Version.

.serena/memories/core.md

@@ -1,70 +1,57 @@
 # core
 
 Ratatoskr-go — оркестратор конвейера Ratatoskr (порт с Python на Go) в единый
-статический бинарь (CGO_ENABLED=0). Субагенты запускаются через внешний процесс
+бинарь. Субагенты (analyst/dev/reviewer) запускаются через внешний процесс
-[opencode](https://opencode.ai). Взаимодействие — Telegram-бот.
+[opencode](https://opencode.ai) (v2 HTTP API). Интерфейсы: Telegram-бот + Fyne UI.
+Linux — статический headless-бинарь (CGO_ENABLED=0); Windows — с Fyne-окном (cgo).
 
 ## Структура (модули internal/)
 
 ```
-cmd/ratatoskr/   точка входа, сборка бинаря; main.version и main.updateToken вшиваются ldflag'ом
+cmd/ratatoskr/   точка входа; флаги: -config, -version, -noui (headless). main.version/updateToken вшиваются ldflag'ом
 internal/
-  app/           composition root/DI: App.New -> config.Load+Validate, ResolveExePaths, storage, Runner, Analyst, Core, Worker, Updater. packageOwner="kamelion", Version="0.1.0"
+  app/           composition root/DI: App.New -> config.Load+Validate, ResolveExePaths, storage, Runner, Analyst, Core, Worker, Updater, UI. packageOwner="kamelion", Version="0.2.2"
   config/        YAML+env загрузка (${VAR:-default}), defaults, validate C1-C4
+  model/         доменные типы/контракты: Status + validTransitions (IsValidTransition/IsTerminal), TraceStatus. Нижний слой — не зависит от storage/events
   chat/          мультиканальный Router; telegram — long-poll канал. Коды M1-M5
   core/          state-machine задач + Decider/analyst интерфейс. Коды D3/D4
   analyst/       аналитик: промпт + разбор JSON-вердикта (opencode agent). Коды A1-A4
+  events/        шина событий UI: Bus (buffered Sub/Pub), типизированный Hub, события TaskCreated/TaskStatusChanged/HistoryAppended/TraceAppended/AgentActivity, LogBus (панель «Логи»)
   worker/        polling-планировщик + dev/reviewer-конвейер + gitops. Коды W*, E*, R*
   agents/        встроенные opencode-агенты (analyst.md, dev.md, reviewer.md) через go:embed
   opencode/      HTTP-клиент v2 API opencode serve, поллинг вердикта, LiveRegistry. Коды O1-O5
   storage/       SQLite (modernc.org/sqlite, без CGO): tasks, traces, task_history. Коды S1-S5
   update/        автообновление из Gitea Packages. Коды U1-U6
+  ui/            desktop-оболочка: Store-абстракция (копии), Commands (UI->Core), Controller (шины->View), View/Window интерфейсы
+  ui/desktop/    Fyne-реализация окна (build-tag cgo, --noui / нет cgo → headless)
+scripts/         build-publish-ui.ps1 — локальная Windows-сборка Fyne-бинаря + публикация в Gitea
+docs/            ui-spec.md — спека Fyne UI (слои, event-bus, fyne.Do/снапшоты)
 ```
 
 ## Ключевые инварианты
 
-- **Команды/ядро:** Core.ProcessTurn — state-machine поверх storage. Команды:
+- **App.New-сигнатура:** `App.New(configPath, version, updateToken string, noUI bool)` (4-й параметр — headless; cgo-вариант собирается только при наличии C-компилятора).
-  /start /cancel /skip /retry N /status N /continue N. Активная задача — одна на чат.
+- **UI:** окно — ещё одна реализация `chat.Channel` (присоединяется в Router). Core не трогает UI; обмен — событийная шина (events). Кнопка «Завершить» = полный выход (SetOnQuit→cancel→UI.Run возвращается); закрытие крестиком = сворачивание, Core живёт. UI собирается с `--noui`/без cgo.
-- **Фазы аналитика (Decision.Phase):** `ask` (уточняющие вопросы), `propose` (правки
+- **Фазы аналитика (Decision.Phase):** `ask`, `propose`, `ready` (два последних обрабатываются одинаково в core), `abort`. Требования валидатора: ask — chat_reply/questions; propose — хотя бы одно изменённое поле; ready — без изменённых полей.
-  черновика), `ready` (черновик полон как есть), `abort` (тема вне проекта). propose и ready
+- **Статусы задач (internal/model):** draft→collecting→ready→approved→running→success/failed/timeout + cancelled/aborted/closed (терминальные). UserID — chat.ID (одна активная задача на чат).
-  в core обрабатываются одинаково.
+- **Decider/Worker/Analyst/Reviewer:** Decider=analyst интерфейс; Worker — polling-планировщик; Reviewer проверяет diff dev-ветки (R1-R6), вердикт JSON {passed, critical_issues, solid_violations, comments}.
-- **Статусы задач:** draft→collecting→ready→approved→running→success/failed/timeout,
+- **gitops (worker):** worktree-режим; feature-ветка `feat/<taskTag>` от origin/main; push через http.extraHeader, токен Bearer.
-  плюс cancelled/aborted/closed. approved — финальное одобрение («создавай»), после чего
+- **Пути «всё рядом с .exe»:** db/worktree резолвятся от ExeDir; config.yaml — рядом с бинарём, фоллбэк cwd.
-  воркер берёт задачу. IsValidTransition/IsTerminal в storage/models.go.
+- **Автообновление:** авто = только Check+уведомление; замена — по /update; версии в `commit-<sha7>/` (не `latest/`); Verify сверяет предprod-версию (binary+в.в) .
-- **Decider/Worker/Analyst/Reviewer:** Decider=analyst интерфейс (analyst пакет реализует);
-  Worker — polling-планировщик dev-агента; Reviewer проверяет diff dev-ветки (R1-R6),
-  вердикт JSON {passed, critical_issues, solid_violations, comments}.
-- **gitops (worker):** worker работает с worktrees; feature-ветка = `feat/<taskTag>` от
-  origin/main; ensureBranch (reset --hard + clean -fd + checkout -B), branchDiff
-  (`origin/main...<branch>`), push через http.extraHeader, токен как Bearer.
-- **Пути «всё рядом с .exe»:** относительные db/worktree резолвятся от каталога бинаря
-  (ExeDir), не от cwd. config.yaml ищутся рядом с бинарём, фоллбэк cwd.
-- **Автообновление:** авто = только Check+уведомление; замена — по /update. Версии в
-  Gitea Packages `commit-<sha7>/` (не `latest/`). Вердикты агентов — строгий JSON.
 
 ## opencode (v2 HTTP API, >= 1.18.18)
 
-- Интеграция с субагентами — через headless `opencode serve`, **v2 API** (префикс `/api/*`).
+- Интеграция с субагентами — через headless `opencode serve`, **v2 API** (`/api/*`). Версия opencode >= 1.18.18.
-  Минимальная версия opencode **>= 1.18.18** (старый бинарь — только `/global/health`, не годится;
+- **Хардпин модели:** при создании сессии читается top-level `model` из конфига opencode (`internal/opencode/config.go`, JSONC-стрип) и передаётся в `POST /api/session` как `{"model":{providerID,id}}`.
-  healthcheck падает с понятной ошибкой, класс O1).
+- **О5 WARN (устойчивость к v1-конфигу):** конфиг по старой схеме молча игнорируется v2; провайдер без api → unsupported модели → fallback. Ratatoskr не чинит сам, но логирует warning; фактическая модель ответа сравнивается с ожидаемой. Правильный v2-вид: `api:{type:"aisdk",package,url}`, `request.headers` вместо `options.headers`.
-- **Хардпин модели:** при создании сессии читается top-level `"model"` из конфига opencode
+- **Поллинг вердикта:** `POST /api/session/:id/prompt` (durable admit) → `GET /api/session/:id/message?order=desc&limit=200` (новые assistant-сообщения, текст в `content[].type=="text"`) → завершение = `GET /api/session/active` без сессии + финальное assistant-сообщение, стабильное `settlePolls=2` опроса. `POST .../interrupt` вместо abort.
-  (`internal/opencode/config.go`, JSONC-стрип `//`/`/* */`/trailing-запятых) и передаётся в
-  `POST /api/session` как `{"model":{providerID,id}}` (разбор `provider/id` по первому `/`).
-- **Класс O5 WARN (устойчивость к v1-конфигу):** конфиг по старой v1-схеме
-  (`provider.X.npm`/`options`) молча игнорируется v2 → провайдер без api → модель unsupported →
-  fallback. Раtatoskr не чинит это сам, но логирует warning: конфиг не читается/нет `model`,
-  и/или фактическая модель ответа (из assistant-сообщения) ≠ ожидаемой. Правильный v2-вид:
-  `api:{type:"aisdk",package,url}` и `request.headers` вместо `options.headers`.
-- **Поллинг вердикта:** `POST /api/session/:id/prompt` (durable admit, неблокирующий) →
-  `GET /api/session/:id/message?order=desc&limit=200` (новые assistant-сообщения, текст в
-  `content[].type=="text"`) → завершение = `GET /api/session/active` без сессии + финальное
-  assistant-сообщение, стабильное `settlePolls=2` опроса. `POST .../interrupt` вместо abort.
-- `ModelRef{ProviderID,ID,Variant}` — аналог v2 Model.Ref; `MinVersion="1.18.18"` в server.go.
 
 ## Контракты (не ломать)
 
-- `App.New(configPath, version, updateToken string)` — сигнатура.
+- `App.New(configPath, version, updateToken string, noUI bool)` — сигнатура.
 - `packageOwner` — константа "kamelion" (не плодить vars/ldflag/конфиг).
 - `update.Updater` — создаётся структурой `&update.Updater{...}`, конструктора нет.
+- `ui.Store` — чтение-модель для UI: ListTasks/GetTask/GetHistory/GetTraces (копии, без ссылок на storage).
+- `events.Bus`/`events.LogBus` — шина UI (см. internal/events). publisher-интерфейсы подключаются к Core/Worker.
 
-См. также `mem:tech_stack`, `mem:conventions`, `mem:task_completion`, `mem:suggested_commands`.
+см. также `mem:tech_stack`, `mem:conventions`, `mem:task_completion`, `mem:suggested_commands`.

.serena/memories/suggested_commands.md

@@ -6,22 +6,27 @@
 - `go fmt ./...` (или `make fmt`).
 - `go build -o ratatoskr ./cmd/ratatoskr/` (или `make build`).
 - `./ratatoskr -config config.yaml` (или `make run`).
-- `./ratatoskr -version` — показать версию бинаря.
+- `./ratatoskr -version` — версия бинаря; `./ratatoskr -noui` — headless (без окна).
-- Кросс-сборка: `make cross` (linux/amd64 + windows/amd64).
+- Кросс-сборка: `make cross` (linux/amd64 + windows/amd64, headless).
+
+## Windows / UI (Fyne)
+- Сборка с UI (cgo): `powershell -ExecutionPolicy Bypass -File scripts/build-publish-ui.ps1`.
+  Требует `scripts/.gitea-creds` (не коммитить) и MinGW/gcc в PATH. См. `mem:toolchain/cgo-winlibs-gcc`.
+- Обычная headless-сборка на Windows без cgo: `go build -o ratatoskr.exe ./cmd/ratatoskr/`.
 
 ## Go-тулчейн
 Хост без `go` в PATH — экспорт вручную:
 ```
 export PATH=/opt/data/.local/go/bin:$PATH
 ```
-На машине разработки (Windows, cmd) — обычный system Go.
+На машине разработки (Windows) — обычный system Go.
 
 ## git (worktree-процесс Ratatoskr)
-- Feature-ветка: `feat/<taskTag>`, база — `origin/main`. Пример проверки diff всей ветки:
+- Feature-ветка: `feat/<taskTag>`, база — `origin/main`. Проверка diff всей ветки:
   `git diff origin/main...HEAD`.
 - Проверить состав отслеживаемых файлов (например наличие .serena): `git ls-files`.
 - Статус: `git status`. Лог: `git log --oneline -10`.
 
 ## Замечания про среду
-- ОС Windows + PowerShell 5.1 (shell: powershell) — команды собирать/запускать с учётом
+- ОС Windows + PowerShell 5.1 (shell: powershell) — нет `&&`; использовать `;`/`if ($?) {}`;
-  этом (нет `&&`; использовать `;`/`if ($?) {}`; & для путей с пробелами).
+  `&` для вызова путей с пробелами. Для серенных файлов лучше отдельная команда `serena memories check`.

.serena/memories/task_completion.md

@@ -6,9 +6,10 @@
 2. **Тесты:** `go test ./... -v -count=1 -timeout 120s` — все проходят (`make test`).
 3. **Статический анализ:** `go vet ./...` — чисто (`make vet`).
 4. **Сборка:** `go build -o ratatoskr ./cmd/ratatoskr/` (`make build`) — компилируется.
-   (Кросс-сборка `make cross` — только при необходимости.)
+   - UI-сборка (cgo+Fyne) проверяется отдельно (`scripts/build-publish-ui.ps1` или `go build` с MinGW);
+     headless-сборка cgo-пакетов (`internal/ui/desktop`) — только typecheck.
 5. **Пересмотр контрактов:** если менялась сигнатура `App.New(configPath, version,
-   updateToken string)` — обновить вызовы в `internal/app/app_test.go` (иначе go vet падает).
+   updateToken string, noUI bool)` — обновить все вызовы (app_test.go, main.go).
 6. Коммит осмысленными атомарными коммитами в feature-ветку `feat/<taskTag>` от origin/main.
 
 Рабочий процесс Ratatoskr (агент dev в этом конвейере): изучить код, реализовать так, чтобы

.serena/memories/tech_stack.md

@@ -1,32 +1,32 @@
 # tech_stack
 
 ## Язык / рантайм
-- Go **1.25.0** (go.mod `go 1.25.0`). Модуль `github.com/kamelion/ratatoskr-go`.
+- Go **1.25.0** (go.mod `go 1.25.0`, module `github.com/kamelion/ratatoskr-go`).
-- Сборка: статический бинарь, `CGO_ENABLED=0`. Локальный Go-тулчейн на хосте:
+- Headless-сборка — статический бинарь `CGO_ENABLED=0`. Windows-сборка с UI — cgo (Fyne/GLFW) + MinGW-w64/gcc.
-  `export PATH=/opt/data/.local/go/bin:$PATH` (go1.25.0 linux/amd64).
+- Локальный Go-тулчейн на хосте: `export PATH=/opt/data/.local/go/bin:$PATH` (go1.25.0 linux/amd64). На Windows — обычный system Go.
 
 ## Основные зависимости (go.mod)
+- `fyne.io/fyne/v2 v2.6.0` — desktop UI (cgo/GLFW; платформа Windows + Linux). Не собирается в CI (headless).
 - `gopkg.in/yaml.v3 v3.0.1` — парсинг config.yaml.
 - `modernc.org/sqlite v1.56.0` — SQLite без CGO (чистый Go).
-- (indirect) google/uuid, go-humanize, mattn/go-isatty, x/sys, modernc.org/libc/mathutil/memory.
+- (indirect) google/uuid, go-humanize, go-text/typesetting, x/sys, x/net, modernc.org/libc и пр.
 
 ## Внешние процессы
-- **opencode** (opencode.ai) — внешний процесс для субагентов (analyst/dev/reviewer).
+- **opencode** (opencode.ai) — субагенты (analyst/dev/reviewer). Управляется через internal/opencode (Runner, Pool, LiveRegistry). Требуемая версия **>= 1.18.18** (v2 HTTP API `/api/*`).
-  Управляется через internal/opencode (Runner, LiveRegistry). Настраивается в конфиге
+- Настройки в конфиге: `opencode.bin / config / config_dir / hard_timeout / idle_timeout / poll_ms` + `opencode.server` (hostname, port, password).
-  (opencode.bin / config / config_dir / hard_timeout / idle_timeout / poll_ms).
+- Подробно — `mem:core`.
-  Требуемая версия opencode: **>= 1.18.18** (v2 HTTP API `/api/*`; хардпин model из конфига —
-  `internal/opencode/config.go`, классы O1/O5). Подробно — `mem:core`.
 
 ## Сборка / Makefile
-- `make build` — go build -ldflags="-s -w -X main.version=commit-<sha7> -X main.updateToken=..." -o ratatoskr ./cmd/ratatoskr/.
+- `make build` — go build `-ldflags="-s -w -X main.version=commit-<sha7> -X main.updateToken=..." -o ratatoskr ./cmd/ratatoskr/`.
-- `make test` — go test ./... -v -count=1 -timeout 120s.
+- `make test` — `go test ./... -v -count=1 -timeout 120s`.
-- `make vet` — go vet ./...   `make fmt` — go fmt ./...
+- `make vet` — `go vet ./...`; `make fmt` — `go fmt ./...`.
-- `make run` — build + ./ratatoskr -config config.yaml.
+- `make run` — build + `./ratatoskr -config config.yaml`.
-- `make cross` — кросс-сборка linux/amd64 + windows/amd64 (ratatoskr-windows-amd64.exe — Windows-машина Камиля).
+- `make cross` — linux/amd64 + windows/amd64 (headless, БЕЗ Fyne-UI; для UI нужен cgo).
-- GIT_SHA вшивается в main.version; UPDATE_TOKEN — в main.updateToken (секрет только у CI).
+- **Fyne-UI (Windows) собирается вручную** на машине с MinGW:
+  `scripts/build-publish-ui.ps1` (cgo) — сборка + публикация в Gitea в версию `commit-<sha7>`.
+  Требует `scripts/.gitea-creds` (git-ignored) и gcc в PATH. См. `mem:toolchain/cgo-winlibs-gcc`.
 
 ## CI (.gitea/workflows/ci.yaml)
-- Job `test`: go test ./... + go vet ./....
+- Job `test`: `go test ./...` + `go vet ./...` (setup-go '1.23', check-latest).
-- Job `build-and-package` (matrix linux/amd64+windows/amd64): собирает и публикует в
+- Job `build-and-package` (matrix linux/amd64 + windows/amd64): собирает headless-бинарь с ldflag update_token, публикует на `main` в версию `commit-<sha7>/` (+ companion `.version`/`.sha256`).
-  Gitea Packages на `main` в версию `commit-<sha7>/` + companion-файлы `.version`/`.sha256`.
+- Секреты: `TC_GITEA_TOKEN` (write:packages), `TC_UPDATE_TOKEN` (read:package), vars `GIT_MAIN_URL`.
-- Секреты: TC_GITEA_TOKEN (write:packages), TC_UPDATE_TOKEN (read:package), GIT_MAIN_URL.

.serena/memories/toolchain/cgo-winlibs-gcc.md

@@ -0,0 +1,13 @@
+# cgo/winlibs-gcc
+
+## MinGW/WinLibs для Fyne-сборки на Windows
+- UI (internal/ui/desktop, fyne.io/fyne/v2) требует cgo + C-компилятор для GLFW.
+- Используется **WinLibs** (mingw64) gcc. Bin каталог нужно добавить в PATH перед
+  `scripts/build-publish-ui.ps1`:
+  ```powershell
+  $p = "<...>\mingw64\bin"; $env:Path = "$p;$env:Path"
+  ```
+- Проверка: `gcc --version`; также убедиться, что `CGO_ENABLED` не = "0".
+- Care: не использовать Cygwin/MSYS-сборки gcc — только native MinGW-w64 (WinLibs).
+- Сборка UI выполняется локально на Windows-машине, публикуется в Gitea Packages
+  в в версию `commit-<sha7>` со companion-.version/.sha256 (контракт U4) — см. скрипт и `mem:tech_stack`.

internal/agents/agents.go

@@ -21,7 +21,7 @@ var FS embed.FS
 //
 // Держим в курсе: если добавить файл в каталог, он автоматически попадёт
 // в FS, но для детерминированной распаковки список лучше дополнять здесь.
-var Names = []string{"analyst", "dev", "reviewer"}
+var Names = []string{"analyst", "dev", "reviewer", "chat"}
 
 // WriteTo распаковывает всех встроенных агентов в каталог dir/agents
 // (создаёт его). Файлы перезаписываются — встроенная копия всегда актуальна.

internal/agents/chat.md

@@ -0,0 +1,17 @@
+---
+name: chat
+description: Свободный чат с Ratatoskr — прямой диалог с LLM без задачи и JSON-вердиктов
+mode: primary
+---
+
+Ты — полезный ассистент в диалоговом режиме. Пользователь пишет тебе произвольные
+сообщения; отвечай на них прямо и по делу, на русском языке, естественно.
+
+Особенности:
+1. Отвечай на вопросы пользователя, помогай с задачами разработки, поясняй код.
+2. Не оборачивай ответ в JSON и не возвращай структурированные вердикты — это
+   свободный диалог, не конвейер задач Ratatoskr.
+3. Если тебе не хватает контекста — задай уточняющий вопрос в обычном тексте.
+4. Пиши кратко и по существу, если пользователь не просит развёрнуто.
+
+Просто продолжай диалог.

internal/app/app.go

@@ -73,6 +73,35 @@ type App struct {
 	// nil — headless-режим (без окна).
 	UI         ui.Window
 	Controller *ui.Controller
+	// FreeChat — свободные диалоги с LLM вне машины задач (in-memory).
+	FreeChat *FreeChat
+}
+
+// FreeChat — свободный LLM-чат (без задачи). Каждый UserID (вкладка UI)
+// держит свою opencode-сессию, чтобы контекст вкладки не смешивался.
+// Транскрипт живёт в памяти окна; здесь только связка uid → opencode sessionID.
+type FreeChat struct {
+	Runner   analyst.OpenCodeRunner
+	Worktree string
+	sessions map[chat.UserID]string // uid → opencode sessionID
+}
+
+// NewFreeChat создаёт сервис свободного чата.
+func NewFreeChat(runner analyst.OpenCodeRunner, worktree string) *FreeChat {
+	return &FreeChat{Runner: runner, Worktree: worktree, sessions: map[chat.UserID]string{}}
+}
+
+// Chat отправляет текст пользователя свободной сессии в opencode (agent="chat")
+// и возвращает ответ модели. Сессия продолжается (resume по sessionID), поэтому
+// каждая вкладка ведёт свой независимый диалог.
+func (f *FreeChat) Chat(ctx context.Context, uid chat.UserID, text string) (string, error) {
+	sid := f.sessions[uid]
+	res, err := f.Runner.Run(ctx, text, f.Worktree, "chat", sid)
+	if err != nil {
+		return "", err
+	}
+	f.sessions[uid] = res.SessionID
+	return res.Stdout, nil
 }
 
 // New читает конфиг и собирает все зависимости.
@@ -212,6 +241,9 @@ func New(configPath, version, updateToken string, noUI bool) (*App, error) {
 	a.Router = router
 	a.Worker = w
 
+	// Свободный LLM-чат (вкладки UI без задачи): общий Runner, свой sessionID на uid.
+	a.FreeChat = NewFreeChat(ocRunner, cfg.Paths.Worktree)
+
 	// /status N читает живое состояние сессии через liveProbe-адаптер.
 	coreCtx.Live = &liveProbe{reg: live}
 
@@ -363,6 +395,10 @@ func (a *App) handleIncoming(inc chat.Incoming) {
 			}
 			a.send(ctx, uid, result.Reply)
 
+		case isUISession(uid):
+			// Свободная UI-вкладка (нет активной задачи): свободный LLM-чат.
+			a.freeChatReply(ctx, uid, text)
+
 		default:
 			a.send(ctx, uid, "Нет активной задачи. /start — создать новую.")
 		}
@@ -427,6 +463,26 @@ func hasArg(text string) bool {
 	return i > 0 && strings.TrimSpace(s[i:]) != ""
 }
 
+// isUISession — true, если UserID принадлежит UI-вкладке-сессии (ui://sess-*).
+func isUISession(uid chat.UserID) bool {
+	return strings.HasPrefix(string(uid), ui.SessionID)
+}
+
+// freeChatReply — ответ свободной LLM-сессии (вкладка UI без активной задачи).
+func (a *App) freeChatReply(ctx context.Context, uid chat.UserID, text string) {
+	if a.FreeChat == nil {
+		a.send(ctx, uid, "Нет активной задачи. /start — создать новую.")
+		return
+	}
+	reply, err := a.FreeChat.Chat(ctx, uid, text)
+	if err != nil {
+		log.Printf("app: free chat %s: %v", uid, err)
+		a.send(ctx, uid, "Ошибка LLM-чата.")
+		return
+	}
+	a.send(ctx, uid, reply)
+}
+
 // ownerUID — куда слать авто-уведомления об обновлении.
 func (a *App) ownerUID() chat.UserID {
 	if a.Config.Telegram.ChatID != "" {

internal/ui/desktop/window.go

@@ -8,6 +8,7 @@ package desktop
 
 import (
 	"context"
+	"fmt"
 	"log"
 	"strings"
 
@@ -25,15 +26,17 @@ import (
 const (
 	selectedPref = "task.selected"
 	splitHPref   = "split.h"
-	splitVPref   = "split.v"
 )
 
 // Window — Fyne-окно: chat.Channel + ui.View.
+//
+// Внутри — вкладки-сессии (ui.Session): каждая вкладка — независимый диалог
+// с LLM (свой UserID/Address, свой активный task). Свободные вкладки (без
+// задачи) создаются кнопкой «Новый чат»; вкладки задач открываются из списка.
 type Window struct {
 	fyneApp fyne.App
 	win     fyne.Window
 	store   ui.Store
-	commands *ui.Commands
 
 	handler chat.Handler
 
@@ -41,14 +44,19 @@ type Window struct {
 	selected int64
 
 	// виджеты
-	taskList  *TaskListPanel
+	taskList *TaskListPanel
-	detail    *TaskDetailPanel
+	detail   *TaskDetailPanel
-	chat      *ChatPanel
+	state    *StatePanel
-	state     *StatePanel
+	logs     *LogPanel
-	logs      *LogPanel
+
+	// вкладки-сессии
+	tabs       *container.AppTabs
+	sessions   map[chat.Address]*ui.Session // Address вкладки → сессия
+	panels     map[chat.Address]*ChatPanel  // Address вкладки → панель
+	tabSession map[*container.TabItem]*ui.Session
+	nextSess   int // счётчик уникальных ui://sess-<n>
 
 	hsplit *container.Split
-	vsplit *container.Split
 
 	onQuit func()
 }
@@ -57,12 +65,14 @@ type Window struct {
 func New(appID string, store ui.Store) *Window {
 	fa := app.NewWithID(appID)
 	w := &Window{
-		fyneApp: fa,
+		fyneApp:    fa,
-		store:   store,
+		store:      store,
+		sessions:   map[chat.Address]*ui.Session{},
+		panels:     map[chat.Address]*ChatPanel{},
+		tabSession: map[*container.TabItem]*ui.Session{},
 	}
 	w.win = fa.NewWindow("Ratatoskr")
 	w.win.SetFullScreen(true)
-	w.commands = ui.NewCommands(w.submitText)
 	w.build()
 	w.win.SetCloseIntercept(func() {
 		// Закрытие окна = сворачивание (спец 12.6): Core продолжает работать.
@@ -79,17 +89,12 @@ func (w *Window) SetOnQuit(fn func()) { w.onQuit = fn }
 // build собирает виджеты и раскладку.
 func (w *Window) build() {
 	w.detail = NewTaskDetailPanel()
-
-	w.chat = NewChatPanel()
-	w.chat.SetCommands(w.commands)
-
 	w.state = NewStatePanel()
-
 	w.logs = NewLogPanel()
 
 	// Список задач (слева)
 	w.taskList = NewTaskListPanel()
-	w.taskList.OnSelect(func(id int64) { w.selectTask(id) })
+	w.taskList.OnSelect(func(id int64) { w.openTaskTab(id) })
 
 	quitBtn := widget.NewButtonWithIcon("Завершить", theme.LogoutIcon(), func() {
 		w.saveLayout()
@@ -99,60 +104,119 @@ func (w *Window) build() {
 	})
 	left := container.NewBorder(nil, quitBtn, nil, nil, w.taskList.Widget())
 
-	// Рабочая область: детали сверху, диалог снизу (сплит 2×2 в плане).
+	// Центр: вкладки-сессии + кнопка «Новый чат».
-	details := w.detail.Widget()
+	w.tabs = container.NewAppTabs()
-	right := container.NewVSplit(
+	w.tabs.OnSelected = func(tab *container.TabItem) {
-		container.NewScroll(details),
+		// фокус вкладки → показываем детали/состояние её задачи
-		w.chat.Transcript(),
+		if s := w.tabSession[tab]; s != nil && s.BoundTask > 0 {
-	)
+			w.selectTask(s.BoundTask)
-	w.vsplit = right
+		}
+	}
+	newBtn := widget.NewButtonWithIcon("Новый чат", theme.ContentAddIcon(), func() {
+		w.addFreeTab()
+	})
+	center := container.NewBorder(newBtn, nil, nil, nil, w.tabs)
 
 	// Нижняя панель: вкладки «Логи» + «Состояние».
 	bottomTabs := container.NewAppTabs(
 		container.NewTabItem("Логи", w.logs.Widget()),
 		container.NewTabItem("Состояние", w.state.Widget()),
 	)
+	bottom := container.NewBorder(nil, nil, nil, nil, bottomTabs)
 
-	bottom := container.NewBorder(nil, w.chat.Composer(), nil, nil, bottomTabs)
+	w.hsplit = container.NewHSplit(left, container.NewVSplit(center, bottom))
-
+	w.win.SetContent(w.hsplit)
-	w.hsplit = container.NewHSplit(left, right)
-
-	root := container.NewVSplit(w.hsplit, bottom)
-	w.win.SetContent(root)
 
 	// Восстановление layout из Preferences.
 	pref := w.fyneApp.Preferences()
 	w.hsplit.SetOffset(pref.FloatWithFallback(splitHPref, 0.30))
-	w.vsplit.SetOffset(pref.FloatWithFallback(splitVPref, 0.45))
 
 	// Начальный снимок списка.
 	w.refreshList()
+
+	// Открываем свободную вкладку-сессию по умолчанию.
+	w.addFreeTab()
 }
 
-// saveLayout сохраняет текущие позиции сплитов в Preferences.
+// addFreeTab создаёт свободную вкладку-сессию (in-memory диалог с LLM).
-// Вызывается при сворачивании окна и перед полным выходом.
+func (w *Window) addFreeTab() {
-func (w *Window) saveLayout() {
+	w.nextSess++
-	pref := w.fyneApp.Preferences()
+	id := fmt.Sprintf("%s%d", ui.SessionID, w.nextSess)
-	pref.SetFloat(splitHPref, w.hsplit.Offset)
+	w.addTab(ui.NewFreeSession(chat.UserID(id), chat.Address(id)))
-	pref.SetFloat(splitVPref, w.vsplit.Offset)
 }
 
-// selectTask загружает детали выбранной задачи (снимки из Store).
+// addTab создаёт вкладку для сессии и фокусирует её.
-func (w *Window) selectTask(id int64) {
+func (w *Window) addTab(sess *ui.Session) {
-	w.selected = id
+	panel := NewChatPanel()
-	w.taskList.Select(id)
+	panel.SetCommands(ui.NewCommands(func(text string) {
-	w.fyneApp.Preferences().SetInt(selectedPref, int(id))
+		w.submitText(sess.UserID, sess.Address, text)
+	}))
 
+	content := container.NewBorder(nil, panel.Composer(), nil, nil, panel.Transcript())
+	tab := container.NewTabItem(sess.Title, content)
+	w.tabs.Append(tab)
+
+	w.sessions[sess.Address] = sess
+	w.panels[sess.Address] = panel
+	w.tabSession[tab] = sess
+
+	w.tabs.Select(tab)
+}
+
+// tabForAddress возвращает вкладку по адресу сессии.
+func (w *Window) tabForAddress(addr chat.Address) *container.TabItem {
+	for tab, s := range w.tabSession {
+		if s.Address == addr {
+			return tab
+		}
+	}
+	return nil
+}
+
+// openTaskTab открывает вкладку задачи (или фокусирует уже открытую).
+//
+// Вкладку можно открыть только для задачи, созданной в UI-сессии (ChatID с
+// префиксом ui://sess-*): её ChatID уникален и не пересекается с Telegram-каналом.
+// Задачи Telegram не открываются в отдельной вкладке — их показывает список и
+// детали (selectTask), чтобы не плодить сессию с общим UserID=чат-id.
+func (w *Window) openTaskTab(id int64) {
 	ctx := context.Background()
 	t, err := w.store.GetTask(ctx, id)
 	if err != nil {
-		w.detail.ShowEmpty()
-		w.chat.Clear()
 		return
 	}
-	w.detail.ShowTask(t)
 
-	// Диалог: история + краткие трассы.
+	// Telegram-задача (ChatID без ui://sess-*) — только детали, без вкладки.
+	if !strings.HasPrefix(t.ChatID, ui.SessionID) {
+		w.selectTask(id)
+		return
+	}
+
+	// Если вкладка для задачи уже есть — фокусируем.
+	for _, s := range w.sessions {
+		if s.BoundTask == id {
+			if tab := w.tabForAddress(s.Address); tab != nil {
+				w.tabs.Select(tab)
+				return
+			}
+		}
+	}
+
+	// Создаём новую вкладку: UserID == task.ChatID (чат задачи уникален).
+	w.nextSess++
+	addr := chat.Address(fmt.Sprintf("%s%d", ui.SessionID, w.nextSess))
+	sess := ui.NewTaskSession(addr, t)
+	w.addTab(sess)
+
+	// Транскрипт из истории задачи.
+	if panel := w.panels[sess.Address]; panel != nil {
+		panel.SetTranscript(w.renderHistory(ctx, id))
+	}
+	w.selectTask(id)
+}
+
+// renderHistory строит транскрипт диалога задачи (история + краткие трассы).
+func (w *Window) renderHistory(ctx context.Context, id int64) string {
 	hist, err := w.store.GetHistory(ctx, id)
 	if err != nil {
 		hist = nil
@@ -172,9 +236,30 @@ func (w *Window) selectTask(id int64) {
 	if b.Len() == 0 {
 		b.WriteString("Нет сообщений. /start — начать задачу.")
 	}
-	w.chat.SetTranscript(b.String())
+	return b.String()
+}
 
-	// Состояние: сброс к снимку задач.
+// saveLayout сохраняет текущие позиции сплитов в Preferences.
+// Вызывается при сворачивании окна и перед полным выходом.
+func (w *Window) saveLayout() {
+	pref := w.fyneApp.Preferences()
+	pref.SetFloat(splitHPref, w.hsplit.Offset)
+}
+
+// selectTask загружает детали выбранной задачи (снимки из Store).
+func (w *Window) selectTask(id int64) {
+	w.selected = id
+	w.taskList.Select(id)
+	w.fyneApp.Preferences().SetInt(selectedPref, int(id))
+
+	ctx := context.Background()
+	t, err := w.store.GetTask(ctx, id)
+	if err != nil {
+		w.detail.ShowEmpty()
+		w.state.SetText(ui.StateText(nil))
+		return
+	}
+	w.detail.ShowTask(t)
 	w.refreshState(ctx, id)
 }
 
@@ -204,18 +289,34 @@ func (w *Window) appendLog(text string) {
 	w.logs.Append(text)
 }
 
-// submitText отправляет ввод пользователя в Router.
+// submitText отправляет ввод пользователя из вкладки в Router.
-func (w *Window) submitText(text string) {
+func (w *Window) submitText(uid chat.UserID, addr chat.Address, text string) {
 	if w.handler != nil {
 		w.handler(chat.Incoming{
-			UserID:  ui.UID,
+			UserID:  uid,
-			Address: ui.Address,
+			Address: addr,
 			Channel: w,
 			Msg:     chat.Message{Text: text},
 		})
 	}
 }
 
+// bindTaskSession связывает свободную вкладку с созданной задачей: когда
+// /start в свободном табе создал задачу с ChatID == UserID этой вкладки,
+// вкладка становится task-сессией (спец: каждая задача — своя вкладка).
+func (w *Window) bindTaskSession(chatID string, taskID int64) {
+	for addr, s := range w.sessions {
+		if string(s.UserID) != chatID || s.BoundTask != 0 {
+			continue
+		}
+		s.BoundTask = taskID
+		if tab := w.tabForAddress(addr); tab != nil {
+			tab.Text = "Задача #" + ui.Itoa(taskID)
+			w.tabs.Refresh()
+		}
+	}
+}
+
 // ---- chat.Channel ----
 
 // OnMessage регистрирует обработчик входящих (Router).
@@ -232,30 +333,37 @@ func (w *Window) Run(ctx context.Context) error {
 	return nil
 }
 
-// Send доставляет сообщение Core в диалог окна.
+// Send доставляет сообщение Core в диалог вкладки по её Address.
-func (w *Window) Send(_ context.Context, _ chat.Address, m chat.Message) error {
+func (w *Window) Send(_ context.Context, to chat.Address, m chat.Message) error {
+	panel, ok := w.panels[to]
+	if !ok {
+		return nil
+	}
 	text := m.Text
 	if len(m.Options) > 0 {
 		var sb strings.Builder
 		sb.WriteString(text)
-		for i, opt := range m.Options {
+		for _, opt := range m.Options {
 			sb.WriteString("\n")
 			sb.WriteString(opt.Label)
-			_ = i
 		}
 		text = sb.String()
 	}
-	fyne.Do(func() { w.chat.Append("🤖 " + text) })
+	fyne.Do(func() { panel.Append("🤖 " + text) })
 	return nil
 }
 
-// Ask — вопрос с вариантами (отображается в диалоге).
+// Ask — вопрос с вариантами (отображается в диалоге вкладки).
-func (w *Window) Ask(_ context.Context, _ chat.Address, m chat.Message) error {
+func (w *Window) Ask(_ context.Context, to chat.Address, m chat.Message) error {
+	panel, ok := w.panels[to]
+	if !ok {
+		return nil
+	}
 	text := m.Text
 	for _, opt := range m.Options {
 		text += "\n" + opt.Label
 	}
-	fyne.Do(func() { w.chat.Append("❓ " + text) })
+	fyne.Do(func() { panel.Append("❓ " + text) })
 	return nil
 }
 
@@ -272,6 +380,8 @@ func (w *Window) Close() error {
 func (w *Window) OnTaskCreated(e events.TaskCreated) {
 	fyne.Do(func() {
 		w.refreshList()
+		// /start в свободной вкладке: вкладка привязывается к задаче.
+		w.bindTaskSession(e.ChatID, e.ID)
 		if w.selected == 0 {
 			w.selectTask(e.ID)
 		}
@@ -308,8 +418,13 @@ func (w *Window) OnTaskStatusChanged(e events.TaskStatusChanged) {
 
 func (w *Window) OnHistoryAppended(e events.HistoryAppended) {
 	fyne.Do(func() {
-		if w.selected == e.TaskID {
+		// история приходит в диалог вкладки задачи
-			w.chat.Append(ui.FormatRole(e.Role) + e.Content)
+		for addr, s := range w.sessions {
+			if s.BoundTask == e.TaskID {
+				if panel, ok := w.panels[addr]; ok {
+					panel.Append(ui.FormatRole(e.Role) + e.Content)
+				}
+			}
 		}
 	})
 }
@@ -329,3 +444,9 @@ func (w *Window) OnAgentActivity(e events.AgentActivity) {
 func (w *Window) OnLog(e events.LogLine) {
 	w.appendLog(e.Text)
 }
+
+// compile-time проверка: окно реализует chat.Channel и ui.View.
+var (
+	_ chat.Channel = (*Window)(nil)
+	_ ui.View      = (*Window)(nil)
+)

internal/ui/session.go

@@ -0,0 +1,43 @@
+package ui
+
+import (
+	"github.com/kamelion/ratatoskr-go/internal/chat"
+	"github.com/kamelion/ratatoskr-go/internal/storage"
+)
+
+// Session — одна вкладка-сессия UI: независимый диалог с LLM.
+//
+// Каждая вкладка имеет собственный UserID и Address, поэтому core видит её как
+// отдельный чат со своим активным task (политика «одна задача на чат» работает
+// из коробки). Свободная сессия (BoundTask==0) — in-memory диалог с моделью
+// вне машины задач; task-сессия (BoundTask>0) — диалог конкретной задачи, у
+// которой UserID == task.ChatID (чат задачи уникален).
+type Session struct {
+	UserID    chat.UserID
+	Address   chat.Address
+	Title     string
+	BoundTask int64 // 0 = свободный чат; >0 — задача, к которой привязана вкладка
+}
+
+// NewFreeSession создаёт свободную сессию (без задачи). userID/address должны
+// быть уникальными (например "ui://sess-<n>"). Транскрипт живёт только в памяти.
+func NewFreeSession(userID chat.UserID, address chat.Address) *Session {
+	return &Session{UserID: userID, Address: address, Title: "Новый чат", BoundTask: 0}
+}
+
+// NewTaskSession создаёт сессию, привязанную к задаче. UserID == task.ChatID,
+// чтобы Router/core находили активную задачу этой вкладки. address — уникальный
+// адрес доставки вкладки (не должен совпадать с UserID других вкладок).
+func NewTaskSession(address chat.Address, t storage.Task) *Session {
+	title := t.Title
+	if title == "" {
+		title = "Задача #" + Itoa(t.ID)
+	}
+	return &Session{UserID: chat.UserID(t.ChatID), Address: address, Title: title, BoundTask: t.ID}
+}
+
+// SessionID — префикс идентификаторов UI-сессий (и UserID, и Address).
+const SessionID = "ui://sess-"
+
+// IsFreeSession — true, если вкладка не привязана к задаче.
+func IsFreeSession(s *Session) bool { return s != nil && s.BoundTask == 0 }

internal/ui/session_test.go

@@ -0,0 +1,55 @@
+package ui
+
+import (
+	"testing"
+
+	"github.com/kamelion/ratatoskr-go/internal/chat"
+	"github.com/kamelion/ratatoskr-go/internal/storage"
+)
+
+func TestNewFreeSession(t *testing.T) {
+	s := NewFreeSession(chat.UserID("ui://sess-1"), chat.Address("ui://sess-1"))
+	if s.UserID != chat.UserID("ui://sess-1") {
+		t.Errorf("UserID = %q, want ui://sess-1", s.UserID)
+	}
+	if s.Address != chat.Address("ui://sess-1") {
+		t.Errorf("Address = %q, want ui://sess-1", s.Address)
+	}
+	if s.BoundTask != 0 {
+		t.Errorf("BoundTask = %d, want 0", s.BoundTask)
+	}
+	if !IsFreeSession(s) {
+		t.Error("free session must be free")
+	}
+}
+
+func TestNewTaskSessionUsesTaskChatID(t *testing.T) {
+	task := &storage.Task{ID: 7, ChatID: "ui://sess-3", Title: "Фича"}
+	s := NewTaskSession(chat.Address("ui://sess-3"), *task)
+	if s.UserID != chat.UserID("ui://sess-3") {
+		t.Errorf("UserID = %q, want task.ChatID", s.UserID)
+	}
+	if s.BoundTask != 7 {
+		t.Errorf("BoundTask = %d, want 7", s.BoundTask)
+	}
+	if s.Title != "Фича" {
+		t.Errorf("Title = %q, want Фича", s.Title)
+	}
+	if IsFreeSession(s) {
+		t.Error("task session must not be free")
+	}
+}
+
+func TestNewTaskSessionTitleFallback(t *testing.T) {
+	task := &storage.Task{ID: 3, ChatID: "ui://sess-3"}
+	s := NewTaskSession(chat.Address("ui://sess-3"), *task)
+	if s.Title != "Задача #3" {
+		t.Errorf("Title = %q, want Задача #3", s.Title)
+	}
+}
+
+func TestIsFreeSessionNil(t *testing.T) {
+	if IsFreeSession(nil) {
+		t.Error("nil is not free")
+	}
+}

scripts/build-publish-ui.ps1

@@ -0,0 +1,109 @@
+<#
+build-publish-ui.ps1 — локальная сборка Windows-бинаря с UI (Fyne) и публикация в Gitea Packages.
+
+Почему локально: Fyne-окно требует cgo + C-компилятор (MinGW/gcc), которых нет в CI.
+CI собирает ТОЛЬКО headless-linux (см. .gitea/workflows/ci.yaml). Windows-бинарь
+с графическим окном собирается на Windows-машине Камиля и публикуется скриптом ниже
+в ту же версию commit-<sha7>, что и CI, с теми же companion-файлами (.version/.sha256),
+чтобы автообновление (U4 checksum, ResolveLatest) работало без изменений.
+
+Требования:
+  - Go с доступным C-компилятором (CGO_ENABLED=1). WinLibs gcc: см. память
+    `mem:toolchain/cgo-winlibs-gcc` — bin нужно добавить в PATH перед запуском.
+  - Файл scripts/.gitea-creds (git-ignored, см. ниже) с токенами.
+    Формат (по одной `ключ=значение` на строку):
+      GITEA_TOKEN=write:packages-токен
+      UPDATE_TOKEN=read:package-токен
+      GIT_MAIN_URL=http://gitea.hal9000.home
+  - Ветка уже запушена в `main` (VERSION = commit-<sha7> от текущего HEAD).
+
+Пример:
+  powershell -ExecutionPolicy Bypass -File scripts/build-publish-ui.ps1
+#>
+
+$ErrorActionPreference = "Stop"
+
+$ScriptDir  = Split-Path -Parent $MyInvocation.MyCommand.Path
+$RepoRoot   = Split-Path -Parent $ScriptDir
+$CredsFile  = Join-Path $ScriptDir ".gitea-creds"
+$Package    = "ratatoskr"
+$Owner      = "kamelion"
+$Filename   = "ratatoskr-windows-amd64.exe"
+
+Set-Location $RepoRoot
+
+# --- 0. Проверка C-тулчейна ---
+if ($env:CGO_ENABLED -eq "0") { Write-Error "CGO_ENABLED=0 — нужен C-компилятор (MinGW). Уберите его из env." }
+if (-not (Get-Command gcc -ErrorAction SilentlyContinue)) {
+    Write-Host "gcc не найден в PATH. Пример (WinLibs):"
+    Write-Host '  $p = "<...>\mingw64\bin"; $env:Path = "$p;$env:Path"'
+    Write-Error "C-компилятор gcc не найден."
+}
+Write-Host "[ok] gcc: $((gcc --version | Select-Object -First 1))"
+
+# --- 1. Чтение секретов ---
+if (-not (Test-Path $CredsFile)) {
+    Write-Error "Нет файла секретов: $CredsFile`nФормат: GITEA_TOKEN=... / UPDATE_TOKEN=... / GIT_MAIN_URL=..."
+}
+$creds = @{}
+Get-Content $CredsFile | ForEach-Object {
+    $line = $_.Trim()
+    if ($line -and -not $line.StartsWith("#")) {
+        $kv = $line.Split("=", 2)
+        if ($kv.Count -eq 2) { $creds[$kv[0].Trim()] = $kv[1].Trim() }
+    }
+}
+$giteaToken = $creds["GITEA_TOKEN"]
+$updateToken = $creds["UPDATE_TOKEN"]
+$giteaUrl = $creds["GIT_MAIN_URL"]
+if (-not $giteaToken) { Write-Error "В $CredsFile нет GITEA_TOKEN (нужен write:packages)." }
+if (-not $giteaUrl)  { Write-Error "В $CredsFile нет GIT_MAIN_URL." }
+
+# --- 2. Версия = commit-<sha7> текущего HEAD (совпадает с именованием CI) ---
+$sha = (git rev-parse --short HEAD).Trim()
+if (-not $sha) { Write-Error "git rev-parse --short HEAD не дал хэш." }
+$Version = "commit-$sha"
+Write-Host "[build] VERSION=$Version  FILENAME=$Filename"
+
+# --- 3. Сборка (cgo + UI) ---
+$env:CGO_ENABLED = "1"
+$out = Join-Path $RepoRoot $Filename
+$ldflags = "-s -w -X main.version=${Version} -X main.updateToken=${updateToken}"
+Write-Host "[build] go build -ldflags=... -o $Filename"
+$goArgs = @("build", "-ldflags=$ldflags", "-o", $out, "./cmd/ratatoskr/")
+go $goArgs
+if ($LASTEXITCODE -ne 0) { Write-Error "go build завершился с кодом $LASTEXITCODE" }
+
+# --- 4. Companion-файлы (.version, .sha256) ---
+$sha256Hex = (Get-FileHash -Algorithm SHA256 $out).Hash.ToLower()
+$verFile   = "$out.version"
+$sumFile   = "$out.sha256"
+Set-Content -Path $verFile -Value $Version -NoNewline -Encoding ascii
+Set-Content -Path $sumFile -Value $sha256Hex -NoNewline -Encoding ascii
+Write-Host "[ok] bin: $out ($([math]::Round((Get-Item $out).Length/1MB,1)) MB)"
+Write-Host "[ok] sha256: $sha256Hex"
+
+# --- 5. Публикация в Gitea Packages ---
+$api = "$giteaUrl/api/packages/$Owner/generic/$Package/$Version"
+$files = @($Filename, "$Filename.version", "$Filename.sha256")
+foreach ($f in $files) {
+    Write-Host "[put] $api/$f"
+    curl.exe -sS -X PUT `
+        -H "Authorization: token $giteaToken" `
+        -H "Content-Type: application/octet-stream" `
+        "$api/$f" `
+        --data-binary "@$f"
+    if ($LASTEXITCODE -ne 0) { Write-Error "curl PUT $f завершился с кодом $LASTEXITCODE" }
+}
+
+# --- 6. Самопроверка: читаем .sha256 обратно и сверяем (контракт U4) ---
+Write-Host "[verify] перечитываю $Filename.sha256 из Gitea..."
+$remoteSum = (curl.exe -sS -H "Authorization: token $giteaToken" "$api/$Filename.sha256").Trim()
+if ($remoteSum -ne $sha256Hex) {
+    Write-Error "Проверка не сошлась: remote=$remoteSum local=$sha256Hex"
+}
+$remoteVer = (curl.exe -sS -H "Authorization: token $giteaToken" "$api/$Filename.version").Trim()
+if ($remoteVer -ne $Version) {
+    Write-Error "Версия не сошлась: remote=$remoteVer local=$Version"
+}
+Write-Host "[ok] опубликовано и проверено: $Version/$Filename (+.version, +.sha256)"