fix(scripts): сборка UI через массив аргументов + UTF-8 BOM

- go build: -ldflags со пробелами передавались одним токеном и падали ("invalid value $ldflags for flag -ldflags"). Вместо этого собираем массив $goArgs и вызываем go через splatting - каждый аргумент отдельным токеном. - Файл перекодирован в UTF-8 с BOM: PowerShell 5.1 без BOM читал .ps1 как ANSI (cp1251) и ломал парсинг кириллических строк. - .gitignore: игнорировать companion-файлы публикации (ratatoskr-*.sha256 / ratatoskr-*.version).
fix(ci): headless в CI, UI-бинарь собирается локально
2026-08-20 17:59:05 +05:00 · 2026-08-20 17:51:46 +05:00
73 changed files with 1064 additions and 4292 deletions
--- a/.gitea/workflows/ci.yaml
+++ b/.gitea/workflows/ci.yaml
@@ -14,6 +14,12 @@ concurrency:
  group: ${{ gitea.workflow }}-${{ gitea.ref }}
  cancel-in-progress: true

+# CI собирает/тестирует ТОЛЬКО headless-вариант: приложение без графического окна
+# (internal/app/ui_noui.go). UI (Fyne-окно) требует cgo и C-компилятора, поэтому
+# собирается локально и публикуется скриптом scripts/build-publish-ui.ps1.
+env:
+  CGO_ENABLED: '0'
+
 jobs:
  test:
    runs-on: ubuntu-latest
@@ -22,11 +28,11 @@ jobs:

      - uses: actions/setup-go@v5
        with:
-          go-version: '1.23'
+          go-version: '1.25'
          check-latest: true

      - name: Run tests
-        run: go test ./... -v -count=1 -timeout 120s 2>&1
+        run: go test ./... -v -count=1 -timeout 300s 2>&1

      - name: Vet
        run: go vet ./...
@@ -34,27 +40,22 @@ jobs:
  build-and-package:
    if: always()
    needs: test
-    strategy:
-      matrix:
-        goos: [linux, windows]
-        goarch: [amd64]
+    # Только linux: headless-бинарь для сервера. Windows-бинарь (с UI, cgo)
+    # публикуется локально через scripts/build-publish-ui.ps1.
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - uses: actions/setup-go@v5
        with:
-          go-version: '1.23'
+          go-version: '1.25'
          check-latest: true

      - name: Build binary
        run: |
-          FILENAME="ratatoskr-${{ matrix.goos }}-${{ matrix.goarch }}"
-          if [ "${{ matrix.goos }}" = "windows" ]; then
-            FILENAME="${FILENAME}.exe"
-          fi
+          FILENAME="ratatoskr-linux-amd64"
          VERSION="commit-$(echo '${{ gitea.sha }}' | cut -c1-7)"
-          GOOS=${{ matrix.goos }} GOARCH=${{ matrix.goarch }} \
+          GOOS=linux GOARCH=amd64 \
            go build -ldflags="-s -w -X main.version=${VERSION} -X main.updateToken=${{ secrets.TC_UPDATE_TOKEN }}" -o "${FILENAME}" ./cmd/ratatoskr/
          echo "FILENAME=${FILENAME}" >> "${GITEA_ENV}"
          echo "VERSION=${VERSION}" >> "${GITEA_ENV}"
--- a/.gitignore
+++ b/.gitignore
@@ -4,6 +4,12 @@
 *.out
 ratatoskr

+# Publish companions (scripts/build-publish-ui.ps1)
+ratatoskr-*.exe.sha256
+ratatoskr-*.exe.version
+ratatoskr-*.sha256
+ratatoskr-*.version
+
 # Go build/test artifacts
 /testbin/
 *.test
@@ -14,6 +20,9 @@ ratatoskr
 !/.env.example
 secrets/

+# Local Gitea credentials for scripts/build-publish-ui.ps1
+scripts/.gitea-creds
+
 # Local config (not tracked — use config.yaml.example)
 config.yaml

--- a/.serena/memories/conventions.md
+++ b/.serena/memories/conventions.md
@@ -1,12 +1,10 @@
 # conventions

 ## Стиль / кодстайл
- Стандартный Go-стиль; `gofmt`/`go fmt ./...`. Документация-комментарии и
-  package-doc на русском языке.
- Типизация: строгие типы, интерфейсы для абстракций (Decider, ui.Store, events.Event, chat.Channel).
+- Стандартный Go-стиль; гофм `gofmt`/`go fmt ./...`. Документация-комментарии и
+  package-doc на русском языке (в START-комментариях файлов и doc-комментариях).
+- Типизация: строгие типы, интерфейсы для абстракций (Decider, LiveProber).
 - Свой тип `config.Duration` для времени (YAML-строки "5s"/"10m"), метод `.Duration()`.
- UI: uni-directional data flow — UI читает снапшоты (копии, `ui.Store`), не мутирует storage/core.
-  Ядро публикует события в `events.Bus`, UI подписывается `events.Hub` → колбэки в UI-поток через `fyne.Do`.

 ## Обработка ошибок
 - Ошибки классифицируются по идентификаторам классов в исходниках (см. ниже).
@@ -17,10 +15,9 @@
 | Блок | Коды | Где |
 |---|---|---|
 | C  | C1–C4 | internal/config |
-| A  | A1–A4 | internal/analyst; A (app): A1–A4 в internal/app |
+| A  | A1–A4 | internal/analyst |
 | M  | M1–M5 | internal/chat |
-| D  | D1–D5 | internal/core (ErrDecideFailed, ErrMaxTurns, ErrCommandUnknown…) |
-| O  | O1–O5 | internal/opencode |
+| O  | O1–O4 | internal/opencode |
 | S  | S1–S5 | internal/storage |
 | W  | W1–W5 | internal/worker |
 | E  | E1–E4 | internal/worker (репозитории) |
@@ -28,27 +25,15 @@
 | U  | U1–U6 | internal/update |

 ## Архитектурные конвенции
- **Composition root** — internal/app; подсистемы собираются там. UI-окно создаётся через
-  `newUIWindow(store)` (build-tag: cgo → desktop.New, !cgo → nil/headless). Флаг `--noui` выключает окно.
- **Слои:** model (домен) ← storage/events/UI зависят только от model; core не знает про UI.
- **Агенты** (analyst.md/dev.md/reviewer.md) — markdown-промпты, go:embed, распаковка в config_dir.
-  Вердикт — строгий JSON.
+- **Composition root** — internal/app; подсистемы собираются там, лимиты Core
+  (MaxTurns=15, MaxConfirmCycles=3, MaxQuestionsPerTurn=5) в core.New.
+- **Агенты** (analyst.md/dev.md/reviewer.md) — markdown-промпты, встроены через go:embed
+  (internal/agents/*.md + embed.go), распаковываются в config_dir. Вердикт — строгий JSON.
 - Репо-клонирование/воркеры — через gitops; ветки задач `feat/<taskTag>` (см. mem:core).
 - Обратная совместимость: поле `Repo` (одиночный) и `Repos` (список); EffectiveRepos/
  SetReposFromDB/ReposJoined в storage/models.go.

 ## Версии
 - `app.Version` — семантическая major.minor.patch (ручной инкремент: patch=фиксы,
-  minor=новая обратно-совместимая функциональность, major=несовместимые изменения). Сейчас 0.2.2.
+  minor=новая обратно-совместимая функциональность, major=несовместимые изменения).
 - `main.version` (ldflag) — build-идентификатор `commit-<sha7>`, отдельно от app.Version.
-
-## Форматирование (важно на Windows)
- Репо на Windows-чекауте: `core.autocrlf=true` → файлы в рабочей копии с CRLF; `gofmt -l`
-  на CRLF-копии шумит (глобально ~60 файлов). **Проверять формат только на LF-версии** (напр.
-  `git -c core.autocrlf=false clone` во временный каталог) — так дифы видны корректно.
- gofmt 1.26 форматирует doc-comments (`//` перед `go build ...` в `//   go build` → пустая строка
-  `//`) и выравнивание структур; не все файлы отформатированы по новой версии (предсуществующе).
- CI (`go vet` + `go test`) формат не проверяет → gofmt-дифы не ломают сборку.
- **Known race в тест-харнессе app:** `e2eChannel.Send` (`internal/app/e2e_test.go:213`) пишет
-  `c.sent` без лока, тест читает с главной горутины → `-race` ловит в `TestE2ENotificationsOnTransitions`.
-  Путь `worker→Notify→Send`; предсуществует, ещё не чинили (fix — мьютекс в `e2eChannel`).
--- a/.serena/memories/core.md
+++ b/.serena/memories/core.md
@@ -1,60 +1,70 @@
 # core

 Ratatoskr-go — оркестратор конвейера Ratatoskr (порт с Python на Go) в единый
-бинарь. Субагенты (analyst/dev/reviewer) запускаются через внешний процесс
-[opencode](https://opencode.ai) (v2 HTTP API). Интерфейсы: Telegram-бот + Fyne UI.
-Linux — статический headless-бинарь (CGO_ENABLED=0); Windows — с Fyne-окном (cgo).
+статический бинарь (CGO_ENABLED=0). Субагенты запускаются через внешний процесс
+[opencode](https://opencode.ai). Взаимодействие — Telegram-бот.

 ## Структура (модули internal/)

 ```
-cmd/ratatoskr/   точка входа; флаги: -config, -version, -noui (headless). main.version/updateToken вшиваются ldflag'ом
+cmd/ratatoskr/   точка входа, сборка бинаря; main.version и main.updateToken вшиваются ldflag'ом
 internal/
-  app/           composition root/DI: App.New -> config.Load+Validate, ResolveExePaths, storage, Runner, Analyst, Core, Worker, Updater, UI. packageOwner="kamelion", Version="0.2.2"
+  app/           composition root/DI: App.New -> config.Load+Validate, ResolveExePaths, storage, Runner, Analyst, Core, Worker, Updater. packageOwner="kamelion", Version="0.1.0"
  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/снапшоты)
 ```

 ## Ключевые инварианты

- **App.New-сигнатура:** `App.New(configPath, version, updateToken string, noUI bool)` (4-й параметр — headless; cgo-вариант собирается только при наличии C-компилятора).
- **chat.Router:** асинхронная обработка входящих — **ограниченный пул `chatWorkers=4` воркеров + FIFO-очереди per-user** (`userState`, `workerLoop`/`runUser`). Порядок сообщений одного UserID сохраняется (флаг `scheduled` → один активный воркер на пользователя); разные пользователи обрабатываются параллельно (до 4 одновременных LLM-вызовов). Backpressure по `jobs` блокирует только перегруженного пользователя, не весь long-poll. `Processed()`/`WaitProcessed()` — синхронизация тестов.
- **FreeChat** (app): `sessions map[uid]sessionID` защищён `sync.Mutex` (пишется из разных воркеров роутера).
- **UI:** окно — ещё одна реализация `chat.Channel` (присоединяется в Router). Core не трогает UI; обмен — событийная шина (events). Кнопка «Завершить» = полный выход (SetOnQuit→cancel→UI.Run возвращается); закрытие крестиком = сворачивание, Core живёт. UI собирается с `--noui`/без cgo.
- **Фазы аналитика (Decision.Phase):** `ask`, `propose`, `ready` (два последних обрабатываются одинаково в core), `abort`. Требования валидатора: ask — chat_reply/questions; propose — хотя бы одно изменённое поле; ready — без изменённых полей.
- **Статусы задач (internal/model):** draft→collecting→ready→approved→running→success/failed/timeout + cancelled/aborted/closed (терминальные). UserID — chat.ID (одна активная задача на чат).
- **Decider/Worker/Analyst/Reviewer:** Decider=analyst интерфейс; Worker — polling-планировщик; Reviewer проверяет diff dev-ветки (R1-R6), вердикт JSON {passed, critical_issues, solid_violations, comments}.
- **gitops (worker):** worktree-режим; feature-ветка `feat/<taskTag>` от origin/main; push через http.extraHeader, токен Bearer.
- **Пути «всё рядом с .exe»:** db/worktree резолвятся от ExeDir; config.yaml — рядом с бинарём, фоллбэк cwd.
- **Автообновление:** авто = только Check+уведомление; замена — по /update; версии в `commit-<sha7>/` (не `latest/`); Verify сверяет контрольную сумму бинаря против `.sha256` той же версии. **Perf:** `ResolveLatest` проверяет наличие бинаря версии **HEAD-пробой без скачивания тела** (405/501 → fallback `GET Range: bytes=0-0`), сортировка версий по id убыв.; один общий `http.Client` (keep-alive). Ошибка U4 — только при несовпадении суммы (пустой/отсутствующий `.sha256` пропускает проверку — M1-известное замечание).
- **Telegram toggle:** `telegram.enabled` (дефолт true, preset в `Load` до unmarshal, т.к. `applyDefaults` для bool не различает явный false). При `false` канал не создаётся/не крепится в Router и long-poll не стартует — сетевых вызовов к api.telegram.org нет; token/chat_id не валидируются.
+- **Команды/ядро:** Core.ProcessTurn — state-machine поверх storage. Команды:
+  /start /cancel /skip /retry N /status N /continue N. Активная задача — одна на чат.
+- **Фазы аналитика (Decision.Phase):** `ask` (уточняющие вопросы), `propose` (правки
+  черновика), `ready` (черновик полон как есть), `abort` (тема вне проекта). propose и ready
+  в core обрабатываются одинаково.
+- **Статусы задач:** draft→collecting→ready→approved→running→success/failed/timeout,
+  плюс cancelled/aborted/closed. approved — финальное одобрение («создавай»), после чего
+  воркер берёт задачу. IsValidTransition/IsTerminal в storage/models.go.
+- **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/*`). Версия opencode >= 1.18.18.
- **Модель — только глобальный конфиг opencode.** Ratatoskr модель не выбирает и про неё не знает: opencode сам берёт модель по умолчанию из своего глобального конфига. Код opencode-конфиг не читает (config.go удалён).
- **Свой агент:** при создании сессии в `POST /api/session` передаётся `agent` (analyst/dev/reviewer/chat/postmortem) из встроенных определений. Агенты распаковываются в `<worktree>/.opencode/agent/*.md` (opencode находит через project-каталог `.opencode`); `OPENCODE_CONFIG_DIR` НЕ выставлять — он перенаправляет Global.Path.config и ломает глобальный конфиг (модель/провайдеры) → падение в fallback.
- **Поллинг вердикта:** `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.
+- Интеграция с субагентами — через headless `opencode serve`, **v2 API** (префикс `/api/*`).
+  Минимальная версия opencode **>= 1.18.18** (старый бинарь — только `/global/health`, не годится;
+  healthcheck падает с понятной ошибкой, класс O1).
+- **Хардпин модели:** при создании сессии читается top-level `"model"` из конфига opencode
+  (`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, noUI bool)` — сигнатура.
+- `App.New(configPath, version, updateToken string)` — сигнатура.
 - `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`.
--- a/.serena/memories/suggested_commands.md
+++ b/.serena/memories/suggested_commands.md
@@ -6,27 +6,22 @@
 - `go fmt ./...` (или `make fmt`).
 - `go build -o ratatoskr ./cmd/ratatoskr/` (или `make build`).
 - `./ratatoskr -config config.yaml` (или `make run`).
- `./ratatoskr -version` — версия бинаря; `./ratatoskr -noui` — headless (без окна).
- Кросс-сборка: `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/`.
+- `./ratatoskr -version` — показать версию бинаря.
+- Кросс-сборка: `make cross` (linux/amd64 + windows/amd64).

 ## Go-тулчейн
 Хост без `go` в PATH — экспорт вручную:
 ```
 export PATH=/opt/data/.local/go/bin:$PATH
 ```
-На машине разработки (Windows) — обычный system Go.
+На машине разработки (Windows, cmd) — обычный 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) — нет `&&`; использовать `;`/`if ($?) {}`;
-  `&` для вызова путей с пробелами. Для серенных файлов лучше отдельная команда `serena memories check`.
+- ОС Windows + PowerShell 5.1 (shell: powershell) — команды собирать/запускать с учётом
+  этом (нет `&&`; использовать `;`/`if ($?) {}`; & для путей с пробелами).
--- a/.serena/memories/task_completion.md
+++ b/.serena/memories/task_completion.md
@@ -6,10 +6,9 @@
 2. **Тесты:** `go test ./... -v -count=1 -timeout 120s` — все проходят (`make test`).
 3. **Статический анализ:** `go vet ./...` — чисто (`make vet`).
 4. **Сборка:** `go build -o ratatoskr ./cmd/ratatoskr/` (`make build`) — компилируется.
-   - UI-сборка (cgo+Fyne) проверяется отдельно (`scripts/build-publish-ui.ps1` или `go build` с MinGW);
-     headless-сборка cgo-пакетов (`internal/ui/desktop`) — только typecheck.
+   (Кросс-сборка `make cross` — только при необходимости.)
 5. **Пересмотр контрактов:** если менялась сигнатура `App.New(configPath, version,
-   updateToken string, noUI bool)` — обновить все вызовы (app_test.go, main.go).
+   updateToken string)` — обновить вызовы в `internal/app/app_test.go` (иначе go vet падает).
 6. Коммит осмысленными атомарными коммитами в feature-ветку `feat/<taskTag>` от origin/main.

 Рабочий процесс Ratatoskr (агент dev в этом конвейере): изучить код, реализовать так, чтобы
--- a/.serena/memories/tech_stack.md
+++ b/.serena/memories/tech_stack.md
@@ -1,32 +1,32 @@
 # tech_stack

 ## Язык / рантайм
- Go **1.25.0** (go.mod `go 1.25.0`, module `github.com/kamelion/ratatoskr-go`).
- Headless-сборка — статический бинарь `CGO_ENABLED=0`. Windows-сборка с UI — cgo (Fyne/GLFW) + MinGW-w64/gcc.
- Локальный Go-тулчейн на хосте: `export PATH=/opt/data/.local/go/bin:$PATH` (go1.25.0 linux/amd64). На Windows — обычный system Go.
+- Go **1.25.0** (go.mod `go 1.25.0`). Модуль `github.com/kamelion/ratatoskr-go`.
+- Сборка: статический бинарь, `CGO_ENABLED=0`. Локальный Go-тулчейн на хосте:
+  `export PATH=/opt/data/.local/go/bin:$PATH` (go1.25.0 linux/amd64).

 ## Основные зависимости (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, go-text/typesetting, x/sys, x/net, modernc.org/libc и пр.
+- (indirect) google/uuid, go-humanize, mattn/go-isatty, x/sys, modernc.org/libc/mathutil/memory.

 ## Внешние процессы
- **opencode** (opencode.ai) — субагенты (analyst/dev/reviewer). Управляется через internal/opencode (Runner, Pool, LiveRegistry). Требуемая версия **>= 1.18.18** (v2 HTTP API `/api/*`).
- Настройки в конфиге: `opencode.bin / config / config_dir / hard_timeout / idle_timeout / poll_ms` + `opencode.server` (hostname, port, password).
- Подробно — `mem:core`.
+- **opencode** (opencode.ai) — внешний процесс для субагентов (analyst/dev/reviewer).
+  Управляется через internal/opencode (Runner, LiveRegistry). Настраивается в конфиге
+  (opencode.bin / config / config_dir / hard_timeout / idle_timeout / poll_ms).
+  Требуемая версия 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 test` — `go test ./... -v -count=1 -timeout 120s`.
- `make vet` — `go vet ./...`; `make fmt` — `go fmt ./...`.
- `make run` — build + `./ratatoskr -config config.yaml`.
- `make cross` — linux/amd64 + windows/amd64 (headless, БЕЗ Fyne-UI; для UI нужен cgo).
- **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`.
+- `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 vet` — go vet ./...   `make fmt` — go fmt ./...
+- `make run` — build + ./ratatoskr -config config.yaml.
+- `make cross` — кросс-сборка linux/amd64 + windows/amd64 (ratatoskr-windows-amd64.exe — Windows-машина Камиля).
+- GIT_SHA вшивается в main.version; UPDATE_TOKEN — в main.updateToken (секрет только у CI).

 ## CI (.gitea/workflows/ci.yaml)
- Job `test`: `go test ./...` + `go vet ./...` (setup-go '1.23', check-latest).
- Job `build-and-package` (matrix linux/amd64 + windows/amd64): собирает headless-бинарь с ldflag update_token, публикует на `main` в версию `commit-<sha7>/` (+ companion `.version`/`.sha256`).
- Секреты: `TC_GITEA_TOKEN` (write:packages), `TC_UPDATE_TOKEN` (read:package), vars `GIT_MAIN_URL`.
+- Job `test`: go test ./... + go vet ./....
+- Job `build-and-package` (matrix linux/amd64+windows/amd64): собирает и публикует в
+  Gitea Packages на `main` в версию `commit-<sha7>/` + companion-файлы `.version`/`.sha256`.
+- Секреты: TC_GITEA_TOKEN (write:packages), TC_UPDATE_TOKEN (read:package), GIT_MAIN_URL.
--- a/.serena/memories/toolchain/cgo-winlibs-gcc.md
+++ b/.serena/memories/toolchain/cgo-winlibs-gcc.md
@@ -1,14 +1,23 @@
-# cgo/winlibs-gcc
+# C-тулчейн для cgo-сборки (Fyne/GLFW) на этой машине

-## MinGW/WinLibs для Fyne-сборки на Windows
- UI (internal/ui/desktop, fyne.io/fyne/v2) требует cgo + C-компилятор для GLFW.
- Установлен постоянно в `D:\MinGW\bin` (WinLibs x86_64-ucrt-posix-seh, GCC 16.2.0),
-  файл `D:\MinGW\bin\gcc.exe` существует. НО каталог не гарантированно в PATH текущей
-  сессии (проверено 2026-08-21: `D:\MinGW\bin` отсутствовал в PATH, `gcc` не находился).
-  `scripts/build-publish-ui.ps1` сам проверяет gcc и при отсутствии подсказывает ручную
-  подстановку PATH (стр. 36–41): `$env:Path = "<...>\mingw64\bin;$env:Path"`.
- Прежняя winget-версия (BrechtSanders.WinLibs.POSIX.UCRT) удалена, чтобы не было дубликата.
- Проверка: `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`.
+WinLibs (BrechtSanders.WinLibs.POSIX.UCRT) установлен через winget как
+portable (zip) в:
+`C:\Users\darkg\AppData\Local\Microsoft\WinGet\Packages\BrechtSanders.WinLibs.POSIX.UCRT_Microsoft.Winget.Source_8wekyb3d8bbwe\mingw64\bin`
+
+- gcc 16.1.0, target `x86_64-w64-mingw32`, рантайм `x86_64-ucrt-posix-seh`.
+- Установлен портативно — НЕ регистрируется в PATH автоматически.
+- PATH добавлен в `HKCU\Environment` (WinLibs bin первым), но в новых
+  PowerShell-процессах opencode окружение НЕ перечитывается, поэтому в каждой
+  команде, где нужен cgo, добавлять вручную:
+    $p = "...\mingw64\bin"; $env:Path = "$p;$env:Path"; $env:CGO_ENABLED = "1"
+
+Важно: на машине есть clang-msvc/i686 (D:\Program Files\LLVM, D:\Program
+Files (x86)\LLVM) — он НЕ подходит для cgo (msvc-таргет + 32bit). Поэтому
+gcc должен идти первым в PATH.
+
+Для сборки окна:  `CGO_ENABLED=1 go build ./...` (компилирует ui_cgo.go и
+internal/ui/desktop). Без cgo окно не собирается — приложение headless
+(ui_noui.go), флаг `--noui` в cmd/ratatoskr/main.go.
+
+Для запуска GUI нужен реальный TG-конфиг (telegram.token/chat_id), иначе app
+падает на init.
--- a/README.md
+++ b/README.md
@@ -3,7 +3,9 @@
 Ratatoskr на Go — **оркестратор в единый статический бинарь** + субагенты через
 [opencode](https://opencode.ai) как внешний процесс. Переезд с Python-версии:
 все подсистемы (диалог, воркер, автообновление) собраны в один исполняемый
-файл без runtime-зависимостей (`CGO_ENABLED=0`), что упрощает доставку и деплой.
+файл, что упрощает доставку и деплой. Бинарь по умолчанию headless
+(`CGO_ENABLED=0`); графическое окно (Fyne) — опционально, собирается с cgo
+(только локально, см. «Локальная сборка UI-бинаря»).

 ## Структура

@@ -58,10 +60,40 @@ GOFLAGS ?= -ldflags="-s -w -X main.version=commit-$(GIT_SHA) -X main.updateToken
 - `main.updateToken` = токен read:package для автообновления (см. ниже). Если не задан
  (`UPDATE_TOKEN ?= ""`) — пустая встройка, тогда обновление берёт `update.token` из конфига.

+**Обычный `make build`/`make cross` окно НЕ включает** — Fyne-окно требует cgo и
+C-компилятора. Headless-бинарь (без окна) собирается и в CI, и локально; UI-бинарь
+с окном — только локально (см. ниже).
+
+### Локальная сборка UI-бинаря (Windows, Fyne-окно) + публикация в Gitea
+
+CI headless: `CGO_ENABLED=0` и публикует только `ratatoskr-linux-amd64`
+(см. `.gitea/workflows/ci.yaml`). Windows-бинарь с окном собирается на Windows-машине
+и публикуется скриптом:
+
+```bash
+# 1) Секреты (git-ignored): скопировать и заполнить
+cp scripts/.gitea-creds.example scripts/.gitea-creds
+#    GITEA_TOKEN=write:packages-токен
+#    UPDATE_TOKEN=read:package-токен
+#    GIT_MAIN_URL=http://gitea.hal9000.home
+
+# 2) Убедиться, что gcc (MinGW) в PATH и CGO_ENABLED=1 — см. память
+#    `mem:toolchain/cgo-winlibs-gcc`
+
+# 3) Запустить (HEAD должен быть тем коммитом, что в main):
+powershell -ExecutionPolicy Bypass -File scripts/build-publish-ui.ps1
+```
+
+Скрипт собирает `ratatoskr-windows-amd64.exe` с `-X main.version=commit-<sha7>` и
+`-X main.updateToken=...`, пишет companion-файлы `.version`/`.sha256` и публикует все
+три в `.../generic/ratatoskr/commit-<sha7>/`. В конце сам перечитывает `.sha256`/`.version`
+из Gitea и сверяет (контракт U4) — как проверка в разделе «Валидация опубликованной версии».
+
 **Как на самом деле публикуется рабочий бинарь:** локальный `go build` токен НЕ вшивает
-(значение секрета есть только у CI). Запушь `main` — CI (см. ниже) сам соберёт оба бинаря
-со вшитым `TC_UPDATE_TOKEN` и загрузит их в Gitea Packages. Так соблюдён least-privilege:
-read-токен не светится на хосте разработки.
+(значение секрета есть только у CI и в git-ignored `scripts/.gitea-creds`). Запушь `main` —
+CI сам соберёт headless-linux со вшитым `TC_UPDATE_TOKEN` и загрузит его в Gitea Packages;
+Windows-бинарь с UI публикуется локальным скриптом (токен read:package в `scripts/.gitea-creds`).
+Так соблюдён least-privilege: read-токен не светится в репозитории/на хосте CI.

 ### Проверки перед сборкой

@@ -78,13 +110,17 @@ make run       # build + ./ratatoskr -config config.yaml

 ## CI (.gitea/workflows/ci.yaml)

- **Job `test`**: checkout → setup-go → `go test ./...` → `go vet ./...`.
- **Job `build-and-package`** (matrix linux/amd64 + windows/amd64, без артефактов):
-  собирает бинарь со вшитым `-X main.updateToken=${secrets.TC_UPDATE_TOKEN}` и
+- **Job `test`**: checkout → setup-go 1.25 → `go test ./...` → `go vet ./...`.
+  Работает в headless-режиме (`CGO_ENABLED=0`, без Fyne/glfw).
+- **Job `build-and-package`** (linux/amd64, без артефактов): собирает **headless**-бинарь
+  `ratatoskr-linux-amd64` со вшитым `-X main.updateToken=${secrets.TC_UPDATE_TOKEN}` и
  **публикует в Gitea Packages** — только на `main`, сразу в версию `commit-<sha7>/`
  (псевдо-версия `latest` НЕ используется — см. автообновление). Плюс companion-файлы
  `<file>.version` и `<file>.sha256`.

+  **Windows-бинарь с UI в CI НЕ собирается** (нужен cgo + C-компилятор). Он собирается
+  и публикуется локально скриптом `scripts/build-publish-ui.ps1` (см. «Локальная сборка UI-бинаря»).
+
 Секреты/vars: `TC_GITEA_TOKEN` (write:packages), `TC_UPDATE_TOKEN` (read:package),
 `GIT_MAIN_URL`.

@@ -95,11 +131,11 @@ make run       # build + ./ratatoskr -config config.yaml

 ```yaml
 telegram:
-  enabled: true            # false — отключить Telegram (без сетевых вызовов к api.telegram.org)
-  token: "..."            # TG_TOKEN (обязательно, если enabled)
-  chat_id: "..."          # TG_CHAT_ID (обязательно, если enabled)
+  token: "..."            # TG_TOKEN
+  chat_id: "..."          # TG_CHAT_ID
 opencode:
  bin: "opencode"
+  config_dir: "./agents"  # каталог, куда распаковываются встроенные агенты
 paths:
  db: "./ratatoskr.db"        # дефолт; резолвится от каталога бинаря (не от cwd)
  worktree: "./worktrees"     # то же правило «всё рядом с .exe»
@@ -131,22 +167,25 @@ update:

 ## Интеграция с opencode (субагенты)

-Субагенты (analyst / dev / reviewer / postmortem) запускаются через **headless** `opencode serve`
+Субагенты (analyst / dev / reviewer) запускаются через **headless** `opencode serve`
 по **v2 HTTP API** (префикс `/api/*`). Требуемая версия opencode: **>= 1.18.18**
 (сборки с v2 HTTP API). Старый бинарь, отвечающий только на `/global/health`,
 не подходит: healthcheck падает с понятной ошибкой (класс O1).

 Что делает обёртка (`internal/opencode`):

- **Модель — только глобальный конфиг opencode.** ratatoskr модель не выбирает
-  и про неё не знает: opencode сам берёт модель по умолчанию из своего
-  глобального конфига (`~/.config/opencode/opencode.jsonc`). Наш код конфиг
-  opencode не читает.
- **Свой агент.** При создании сессии в `POST /api/session` передаётся имя
-  встроенного агента ratatoskr (analyst/dev/reviewer/chat/postmortem). Агенты
-  распаковываются в `<worktree>/.opencode/agent/*.md`, где opencode находит
-  их через project-каталог `.opencode` (см. `internal/agents`); глобальный
-  конфиг при этом не трогается.
+- **Хардпин модели.** При создании сессии в конфиге opencode ищется top-level
+  `"model"` (`internal/opencode/config.go`) и передаётся в `POST /api/session`
+  как `{"model":{providerID,id}}`. Это убирает зависимость от fallback-логики
+  opencode (которая молча выбирает «дефолтную» запись, если модель не задана).
+- **Весь код резолва модели устойчив к этому классу проблем (класс O5 WARN):**
+  - если конфиг не читается / в нём нет `model` — в логи пишется warning;
+  - фактическая модель ответа (из финального assistant-сообщения) сравнивается
+    с ожидаемой; расхождение логируется как warning;
+  - конфиг, написанный по **старой v1-схеме** (`provider.X.npm` / `options`),
+    молча игнорируется v2 — обёртка этого не «чинит» сама, но предупреждает.
+    Правильный v2-вид провайдера — `api: { type:"aisdk", package, url }` и
+    `request.headers` вместо `options.headers`.
 - **Поллинг вердикта.** Промпт отправляется неблокирующе (`POST .../prompt` →
  durable admit), вердикт собирается из новых assistant-сообщений
  (`GET .../message`); завершение ответа — сессия ушла из активных дренажей
@@ -170,18 +209,6 @@ update:
 В `internal/core` фазы `propose` и `ready` обрабатываются одинаково (применить черновик,
 проверить репозитории, поставить `ready` и отдать резюме).

-## Постмортем после failed/timeout
-
-Когда задача завершилась `failed` или `timeout`, воркер дополнительно запускает
-**постмортем-анализ** (`internal/worker/postmortem.go`, agent `postmortem`):
-
- анализирует сессии dev/reviewer (промпты и выводы из `traces`);
- оценивает законченность этапов и причины сбоя;
- сохраняет результат как trace `agent=postmortem` и шлёт владельцу уведомление
-  «🔍 анализ (после <статус>): почему так случилось / что сделать».
-
-Статус задачи постмортем не меняет; сбои самого анализа не влияют на исход задачи.
-
 ## Автообновление из Gitea Packages

 Бинарь умеет сам себя обновлять из generic-пакета в Gitea. Модель:
@@ -208,9 +235,12 @@ update:
 ### Как опубликовать новую версию

 1. Внеси правки, коммитни, запуши в `main`.
-2. CI соберёт оба бинаря со вшитым `TC_UPDATE_TOKEN` и опубликует в
+2. CI соберёт `ratatoskr-linux-amd64` (headless) со вшитым `TC_UPDATE_TOKEN` и опубликует в
   `.../generic/ratatoskr/commit-<sha7>/` (бинарь + `.version` + `.sha256`).
-3. На обновляемой машине: бот сам уведомит о новой версии → `/update`.
+3. Если в этой версии есть изменения UI — дополнительно собрать и опубликовать
+   Windows-бинарь с окном: `scripts/build-publish-ui.ps1` (добавит
+   `ratatoskr-windows-amd64.exe` в ту же версию).
+4. На обновляемой машине: бот сам уведомит о новой версии → `/update`.

 Проверку автообновления после публикации гоняет владелец на своей
 Windows-машине (не прогоняется агентом).
--- a/config.yaml.example
+++ b/config.yaml.example
@@ -1,20 +1,18 @@
 # ratatoskr-go пример конфигурации.
 # Можно не указывать поля, у которых есть дефолт (см. internal/config/types.go).
-# Если telegram.enabled: true (дефолт) — обязательно: telegram.token + telegram.chat_id.
+# Обязательно: telegram.token + telegram.chat_id

 telegram:
-  enabled: true                 # false — полностью отключить Telegram (без сетевых вызовов)
-  token: "${TG_TOKEN}"        # токен Telegram бота (обязательно, если enabled)
-  chat_id: "${TG_CHAT_ID}"    # ID чата (обязательно, если enabled)
+  token: "${TG_TOKEN}"        # токен Telegram бота (обязательно)
+  chat_id: "${TG_CHAT_ID}"    # ID чата (обязательно)

 # Всё ниже — опционально, показаны дефолты:
 # opencode:
 #   bin: "opencode"
+#   config: "/путь/к/opencode.json"      # файл-конфиг модели (OPENCODE_CONFIG)
+#   config_dir: "./agents"               # каталог с агентами (OPENCODE_CONFIG_DIR)
 #   hard_timeout: "20m"
 #   idle_timeout: "5m"
-#
-# Агенты (analyst/dev/reviewer/...) распаковываются автоматически в
-# <worktree>/.opencode/agent/*.md; конфиг opencode для этого не нужен.

 # git (источник репозиториев для git clone)
 #   base_url: "http://gitea.hal9000.home"   # базовый URL git-хоста (обязательно для клонирования)
--- a/docs/ui-spec.md
+++ b/docs/ui-spec.md
@@ -157,96 +157,6 @@
 приложение работает headless (UI=nil). Реальное окно полноценно проверяется
 на машине с MinGW-w64/gcc (`go build -ldflags ...`), здесь — только typecheck.

-### 12.8. Структура UI-кода: компоненты-виджеты (рефакторинг)
-
-`internal/ui` (без Fyne) — контракты + Nil-реализации + юнит-тесты. Fyne-код —
-только в `internal/ui/desktop/*`, один файл — одна панель. `desktop/window.go`
-становится чистой компоновкой.
-
-Каждый компонент:
- **интерфейс** в `internal/ui/<panel>.go` (контракт для тестов/headless);
- **Nil-реализация** в том же файле (headless/тесты);
- **Fyne-реализация** в `internal/ui/desktop/<panel>.go`.
-
-### 12.9. Контракт виджета «Логи» (LogPanel)
-
-Панель «Логи» — поток системных логов из `events.LogLine` (уровень + строка).
-
- `Append(level, text)` — добавить запись лога; уровень нормализуется к одному
-  из четырёх (`ui.NormalizeLogLevel`: error/warning/info/debug, неизвестные →
-  info); при превышении лимита старые записи отбрасываются (буфер ограничен,
-  не расти бесконечно).
- **Фильтр уровней**: над лентой — выпадающий список с чекбоксами
-  (error/warning/info/debug). По умолчанию отмечены все уровни (виден полный
-  лог); показываются только записи выбранных уровней; изменение набора сразу
-  перерисовывает ленту — и по уже загруженным записям, и для вновь
-  поступающих. Если ни один уровень не выбран — лента пуста (без ошибок).
- Контейнер виджета — отдаётся окну для встраивания в таб «Логи» (строка
-  фильтра + Scroll с лентой).
- Обновление содержимого — на потоке Fyne (внутри панели `fyne.Do`), не из
-  горутины Hub.
-
-### 12.10. Контракт виджета «Список задач» (TaskListPanel)
-
-Список задач — левая панель окна: все задачи (`storage.Task`) строками.
-
- `SetTasks(tasks)` — заменить снимок списка и перерисовать виджет. Данные —
-  копии из Store (спец 12.5).
- `OnSelect(fn)` — колбэк клика по строке; окно грузит детали выбранной задачи
-  (это `task_detail`, отдельный компонент). Состояние выбора живёт в окне.
- Выбранная строка подсвечивается (`Select`/`Unselect`), окно управляет ею.
- Строка = `taskTitle(t)` (pure-функция, тестируется без Fyne).
- Обновление — на потоке Fyne; вызывающий уже внутри `fyne.Do`, панель сама
-  виджет не трогает из горутин Hub.
-
-### 12.11. Контракт виджета «Детали задачи» (TaskDetailPanel)
-
-Детали выбранной задачи — верх `right`-сплита: заголовок, статус, детали
-(цель + репозитории).
-
- `ShowTask(t)` — рендер из снимка `storage.Task`: заголовок (bold), статус
-  (italic), детали = `TaskDetailText(t)`.
- `ShowEmpty()` — сброс к placeholder («—» / пусто) при недоступной задаче.
- Строка деталей = pure `TaskDetailText(t)` (цель + репо), тестируется без Fyne.
- Обновление — на потоке Fyne; вызывающий уже внутри `fyne.Do`.
- Диалог и «Состояние» — отдельные панели (chat_panel, state_panel), здесь
-  не участвуют; окно оркестрирует загрузку всех панелей по выбору задачи.
-
-### 12.12. Контракт виджета «Диалог» (ChatPanel)
-
-Диалог — транскрипт общения с выбранной задачей + композитор (поле ввода и
-кнопки команд).
-
- Транскрипт:
-  - `SetTranscript(text)` — полный рендер истории выбранной задачи;
-  - `Append(text)` — добавить строку; при превышении лимита старые строки
-    отбрасываются (буфер ограничен);
-  - `Clear()` — очистить при недоступной задаче.
- Композитор: поле ввода + кнопки команд, подключённые к `ui.Commands` через
-  `SetCommands(c)` (ввод → `SendText`, кнопки → Start/Approve/Skip/Retry/Cancel).
- Кнопка «Перезапустить» — полный аналог Telegram-команды `/retry N`: отправляет
-  `/retry N` тем же путём, что и ручной ввод (Commands → Router → Core).
-  Активна только для вкладки с привязанной задачей; окно сообщает ID задачи
-  через `SetBoundTask(taskID)` (при создании вкладки в `addTab` и при привязке
-  свободной вкладки в `bindTaskSession`); `0` — кнопка неактивна.
- Доставка: окно (как chat.Channel) рендерит `Send`/`Ask`/историю через
-  `Append`; строка роли = pure `FormatRole(role)` (👤/🤖).
- Обновление — на потоке Fyne; вызывающий уже внутри `fyne.Do`.
-
-### 12.13. Контракт виджета «Состояние» (StatePanel)
-
-Панель «Состояние» — агенты + трейсы выбранной задачи: снимок и live-строки.
-
- `SetText(text)` — полный рендер снимка трасс выбранной задачи.
- `Append(text)` — добавить строку; при превышении лимита старые строки
-  отбрасываются (буфер ограничен).
- Строка снимка = pure `StateText(traces)` (агент: статус, session).
- Live-строки (чистые хелперы, окно зовёт `Append` с готовой строкой):
-  - `TraceLine(agent, status)` — добавлен/обновлён трейс субагента;
-  - `ActivityLine(agent, stage)` — смена этапа агента;
-  - `TaskStatusText(e)` — изменение статуса задачи (бейдж + ID).
- Обновление — на потоке Fyne; вызывающий уже внутри `fyne.Do`.
-
 ---

 ## Открытые пункты (TODO)
--- a/internal/agents/agents.go
+++ b/internal/agents/agents.go
@@ -1,10 +1,12 @@
 // Package agents — встроенные агенты opencode (analyst, dev, ...).
 //
 // Агенты зашиты в бинарь через go:embed и распаковываются при запуске
-// в project-каталог <worktree>/.opencode/agent/*.md. opencode при serve
-// (cwd = worktree) обнаруживает .opencode поднятием вверх (ConfigPaths) и
-// находит агентов по шаблону {agent,agents}/**/*.md. Глобальный конфиг
-// opencode остаётся нетронутым (OPENCODE_CONFIG_DIR не выставляем).
+// в каталог OPENCODE_CONFIG_DIR (по умолчанию ./agents рядом с бинарём),
+// чтобы opencode находил их независимо от того, где запущен ratatoskr.
+//
+// opencode сканирует OPENCODE_CONFIG_DIR как каталог .opencode: агенты
+// ищутся в поддиректории agents/ (мн.ч.), а не в корне. Поэтому распаковка
+// идёт в <dir>/agents/*.md.
 package agents

 import (
@@ -19,9 +21,9 @@ var FS embed.FS
 //
 // Держим в курсе: если добавить файл в каталог, он автоматически попадёт
 // в FS, но для детерминированной распаковки список лучше дополнять здесь.
-var Names = []string{"analyst", "dev", "reviewer", "chat", "postmortem"}
+var Names = []string{"analyst", "dev", "reviewer"}

-// WriteTo распаковывает всех встроенных агентов в каталог dir/agent
+// WriteTo распаковывает всех встроенных агентов в каталог dir/agents
 // (создаёт его). Файлы перезаписываются — встроенная копия всегда актуальна.
 func WriteTo(dir string) error {
 	agentsDir := filepath.Join(dir, "agents")
--- a/internal/agents/agents_test.go
+++ b/internal/agents/agents_test.go
@@ -13,7 +13,7 @@ func TestWriteTo(t *testing.T) {
 		t.Fatalf("WriteTo: %v", err)
 	}
 	for _, name := range Names {
-		// opencode ищет агентов в поддиректории agent/ (или agents/) внутри .opencode
+		// opencode ищет агентов в поддиректории agents/, как у .opencode
 		p := filepath.Join(dir, "agents", name+".md")
 		data, err := os.ReadFile(p)
 		if err != nil {
--- a/internal/agents/analyst.md
+++ b/internal/agents/analyst.md
@@ -2,20 +2,6 @@
 name: analyst
 description: Аналитик Ratatoskr — помогает сформулировать задачу разработки и возвращает структурированное решение в JSON
 mode: primary
-tools:
-  read: true
-  write: true
-  edit: false
-  bash: true
-  grep: true
-  glob: true
-  websearch: false
-  webfetch: false
-permission:
-  question: deny
-  edit: deny
-  bash:
-    "*": allow
 ---

 Ты — аналитик в конвейере Ratatoskr. Пользователь ставит задачу разработки. Ты помогаешь
--- a/internal/agents/chat.md
+++ b/internal/agents/chat.md
@@ -1,17 +0,0 @@
---
-name: chat
-description: Свободный чат с Ratatoskr — прямой диалог с LLM без задачи и JSON-вердиктов
-mode: primary
---
-
-Ты — полезный ассистент в диалоговом режиме. Пользователь пишет тебе произвольные
-сообщения; отвечай на них прямо и по делу, на русском языке, естественно.
-
-Особенности:
-1. Отвечай на вопросы пользователя, помогай с задачами разработки, поясняй код.
-2. Не оборачивай ответ в JSON и не возвращай структурированные вердикты — это
-   свободный диалог, не конвейер задач Ratatoskr.
-3. Если тебе не хватает контекста — задай уточняющий вопрос в обычном тексте.
-4. Пиши кратко и по существу, если пользователь не просит развёрнуто.
-
-Просто продолжай диалог.
--- a/internal/agents/dev.md
+++ b/internal/agents/dev.md
@@ -2,20 +2,6 @@
 name: dev
 description: Разработчик Ratatoskr — реализует задачу в репозитории по готовым критериям
 mode: primary
-tools:
-  read: true
-  write: true
-  edit: true
-  bash: true
-  grep: true
-  glob: true
-  websearch: false
-  webfetch: false
-permission:
-  question: deny
-  edit: allow
-  bash:
-    "*": allow
 ---

 Ты — dev-агент в конвейере Ratatoskr. Получаешь готовое задание и реализуешь его в коде.
--- a/internal/agents/postmortem.md
+++ b/internal/agents/postmortem.md
@@ -1,49 +0,0 @@
---
-name: postmortem
-description: Постмортем-аналитик Ratatoskr — анализирует сессии dev/reviewer после failed/timeout задачи и даёт резюме: почему так и что сделать, чтобы не повторялось
-mode: primary
-tools:
-  read: false
-  write: false
-  edit: false
-  bash: false
-  grep: false
-  glob: false
-  list: false
-  websearch: false
-  webfetch: false
-permission:
-  question: deny
-  edit: deny
-  read: deny
-  glob: deny
-  grep: deny
-  list: deny
-  bash:
-    "*": deny
-  webfetch: deny
-  websearch: deny
---
-
-Ты — постмортем-аналитик в конвейере Ratatoskr. Задача завершилась неудачей (failed) или таймаутом (timeout). Ты анализируешь, что пошло не так, и даёшь резюме, которое поможет не допускать этого впредь.
-
-Тебе приходит промпт с:
- задачей (название, цель, критерии готовности AC, репозитории, итоговый статус);
- сессиями субагентов dev и/или reviewer: их статус (success/failed/timeout), промпт и вывод (output).
-
-ПРАВИЛА:
-1. Проанализируй сессии dev и reviewer: какие в них проблемы, насколько завершён каждый этап (разработка, ревью).
-2. Оцени «законченность этапов»: что успел сделать dev, проверял ли reviewer весь дифф, были ли заблокированы работы.
-3. Сделай вывод — **почему так случилось**: ошибка в задании, неясные AC, технический сбой, неорганизованная работа агента и т.п.
-4. Дай рекомендации — «что сделать, чтобы этого не было»: как уточнять задачу, какие AC добавлять, какой контекст предавать агентам, какие этапы конвейера ужесточить.
-5. ПИШИ СВОЙ ОТВЕТ **ПРОСТЫМ ТЕКСТОМ НА РУССКОМ ЯЗЫКЕ**, без JSON, без markdown-обёрток и лишней разметки.
-
-Формат ответа (два обязательных блока, коротко и по делу):
-
-Почему так случилось:
- <причина 1>
- <причина 2>
-
-Что сделать, чтобы это не повторялось:
- <рекомендация 1>
- <рекомендация 2>
--- a/internal/agents/reviewer.md
+++ b/internal/agents/reviewer.md
@@ -2,20 +2,6 @@
 name: reviewer
 description: Ревьюер Ratatoskr — строго проверяет ветку работы dev-агента (качество, безопасность, SOLID) и возвращает вердикт в JSON
 mode: primary
-tools:
-  read: true
-  write: true
-  edit: false
-  bash: true
-  grep: true
-  glob: true
-  websearch: false
-  webfetch: false
-permission:
-  question: deny
-  edit: deny
-  bash:
-    "*": allow
 ---

 Ты — ревьюер в конвейере Ratatoskr. Проверяешь работу dev-агента в feature-ветке **жёстко и придирчиво**. Твоя цель — не дать плохому коду попасть в основную ветку.
--- a/internal/analyst/analyst.go
+++ b/internal/analyst/analyst.go
@@ -54,55 +54,14 @@ type AnalystResponse struct {
 	Title       string   `json:"title"`
 	Goal        string   `json:"goal"`
 	Repo        string   `json:"repo"`   // одиночный репо (обратная совместимость)
-	Repos       json.RawMessage `json:"repos"` // список репо (основной); устойчив к строке
+	Repos       []string `json:"repos"`  // список репо (основной)
 	Why         string   `json:"why"`
 	AC          string   `json:"ac"`
-	Steps       []storage.Step  `json:"steps"`
 	Questions   []string `json:"questions"`
 	ChatReply   string   `json:"chat_reply"`
 	AbortReason string   `json:"abort_reason"`
 }

-// reposList нормализует поле repos: модель может вернуть либо массив
-// ["a","b"], либо строку "a,b" (иногда с пробелами). Пустое значение → nil.
-func (r *AnalystResponse) reposList() []string {
-	if r.Repos == nil {
-		return nil
-	}
-	var arr []string
-	if err := json.Unmarshal(r.Repos, &arr); err == nil {
-		return arr
-	}
-	var s string
-	if err := json.Unmarshal(r.Repos, &s); err != nil {
-		return nil
-	}
-	var out []string
-	for _, p := range strings.Split(s, ",") {
-		p = strings.TrimSpace(p)
-		if p != "" {
-			out = append(out, p)
-		}
-	}
-	return out
-}
-
-// stepsList возвращает этапы: модель может вернуть массив объектов либо
-// пустой/отсутствующий — тогда nil. Записи без title отбрасываются.
-func (r *AnalystResponse) stepsList() []storage.Step {
-	if r.Steps == nil {
-		return nil
-	}
-	var out []storage.Step
-	for _, st := range r.Steps {
-		if st.Title == "" {
-			continue
-		}
-		out = append(out, st)
-	}
-	return out
-}
-
 // Decide реализует core.Decider через открытый код.
 func (a *Analyst) Decide(ctx context.Context, history []core.Message, draft storage.Task, force bool) (core.Decision, error) {
 	agent := a.Agent
@@ -126,7 +85,6 @@ func (a *Analyst) Decide(ctx context.Context, history []core.Message, draft stor
 		Repos:   draft.EffectiveRepos(),
 		Why:     draft.Why,
 		AC:      draft.AC,
-		Steps:   draft.Steps,
 		History: hist,
 		Force:   force,
 	}
@@ -146,7 +104,12 @@ func (a *Analyst) Decide(ctx context.Context, history []core.Message, draft stor

 	// 4. парсим вердикт
 	verdict := opencode.ExtractVerdict(res.Stdout)
+	log.Printf("analyst: verdict tail: %s", truncate(verdict, 2000))
 	obj, ok := opencode.ExtractJSON(verdict)
+	if ok {
+		b, _ := json.Marshal(obj)
+		log.Printf("analyst: extracted json: %s", truncate(string(b), 1000))
+	}
 	if !ok {
 		return core.Decision{}, fmt.Errorf("%w: нет JSON в выводе аналитика", ErrDecodeFail)
 	}
@@ -160,8 +123,6 @@ func (a *Analyst) Decide(ctx context.Context, history []core.Message, draft stor
 		return core.Decision{}, fmt.Errorf("%w: %v", ErrDecodeFail, err)
 	}

-	log.Printf("analyst: вердикт: %s", truncate(formatVerdict(&ar), 2000))
-
 	// 5. валидация
 	if err := validateResponse(&ar); err != nil {
 		return core.Decision{}, fmt.Errorf("%w: %v", ErrValidation, err)
@@ -183,10 +144,10 @@ func (a *Analyst) Decide(ctx context.Context, history []core.Message, draft stor
 	if ar.Repo != "" {
 		dec.Draft.Repo = ar.Repo
 	}
-	if repos := ar.reposList(); len(repos) > 0 {
-		dec.Draft.Repos = repos
+	if len(ar.Repos) > 0 {
+		dec.Draft.Repos = ar.Repos
 		// Синхронизируем одиночный repo для старых потребителей.
-		dec.Draft.Repo = strings.Join(repos, ",")
+		dec.Draft.Repo = strings.Join(ar.Repos, ",")
 	}
 	if ar.Why != "" {
 		dec.Draft.Why = ar.Why
@@ -194,9 +155,6 @@ func (a *Analyst) Decide(ctx context.Context, history []core.Message, draft stor
 	if ar.AC != "" {
 		dec.Draft.AC = ar.AC
 	}
-	if steps := ar.stepsList(); len(steps) > 0 {
-		dec.Draft.Steps = steps
-	}

 	return dec, nil
 }
@@ -225,7 +183,7 @@ func validateResponse(ar *AnalystResponse) error {
 			return fmt.Errorf("phase=ask, но нет ни chat_reply, ни questions")
 		}
 	case "propose":
-		if ar.Title == "" && ar.Goal == "" && len(ar.Repos) == 0 && ar.Why == "" && ar.AC == "" && len(ar.stepsList()) == 0 {
+		if ar.Title == "" && ar.Goal == "" && len(ar.Repos) == 0 && ar.Why == "" && ar.AC == "" {
 			return fmt.Errorf("phase=propose, но нет ни одного изменённого поля")
 		}
 	case "ready":
@@ -237,63 +195,3 @@ func validateResponse(ar *AnalystResponse) error {
 	}
 	return nil
 }
-
-// formatVerdict собирает человекочитаемое однострочное описание вердикта
-// аналитика (без JSON-разметки) для панели «Логи».
-func formatVerdict(ar *AnalystResponse) string {
-	var b strings.Builder
-	b.WriteString("phase=" + ar.Phase)
-
-	if ar.ChatReply != "" {
-		b.WriteString(", chat_reply=")
-		b.WriteString(ar.ChatReply)
-	}
-	if len(ar.Questions) > 0 {
-		b.WriteString(", questions=[")
-		b.WriteString(strings.Join(ar.Questions, " | "))
-		b.WriteString("]")
-	}
-	if ar.Title != "" {
-		b.WriteString(", title=")
-		b.WriteString(ar.Title)
-	}
-	if ar.Goal != "" {
-		b.WriteString(", goal=")
-		b.WriteString(ar.Goal)
-	}
-	if ar.Repo != "" {
-		b.WriteString(", repo=")
-		b.WriteString(ar.Repo)
-	}
-	if repos := ar.reposList(); len(repos) > 0 {
-		b.WriteString(", repos=[")
-		b.WriteString(strings.Join(repos, ", "))
-		b.WriteString("]")
-	}
-	if ar.Why != "" {
-		b.WriteString(", why=")
-		b.WriteString(ar.Why)
-	}
-	if ar.AC != "" {
-		b.WriteString(", ac=")
-		b.WriteString(ar.AC)
-	}
-	if steps := ar.stepsList(); len(steps) > 0 {
-		b.WriteString(", steps=[")
-		var parts []string
-		for _, st := range steps {
-			s := st.Title
-			if st.AC != "" {
-				s += " → " + st.AC
-			}
-			parts = append(parts, s)
-		}
-		b.WriteString(strings.Join(parts, " | "))
-		b.WriteString("]")
-	}
-	if ar.AbortReason != "" {
-		b.WriteString(", abort_reason=")
-		b.WriteString(ar.AbortReason)
-	}
-	return b.String()
-}
--- a/internal/analyst/analyst_test.go
+++ b/internal/analyst/analyst_test.go
@@ -2,9 +2,7 @@ package analyst

 import (
 	"context"
-	"encoding/json"
 	"errors"
-	"strings"
 	"testing"

 	"github.com/kamelion/ratatoskr-go/internal/core"
@@ -218,133 +216,3 @@ func TestAskEmptyReplyAndQuestions(t *testing.T) {
 		t.Errorf("err = %v, want A3", err)
 	}
 }
-
-// TestDecideProposeStringRepos — модель вернула repos строкой (а не массивом):
-// парсер должен нормализовать и не падать.
-func TestDecideProposeStringRepos(t *testing.T) {
-	a := &Analyst{Runner: &mockRunner{result: &opencode.Result{
-		RC:     0,
-		Stdout: `{"type":"text","part":{"text":"{\"phase\":\"propose\",\"title\":\"Калькулятор\",\"repos\":\"tools/calc, tools/ui\"}"}}`,
-	}}, Worktree: "/tmp"}
-
-	history := []core.Message{{Role: "user", Content: "Сделай калькулятор"}}
-	dec, err := a.Decide(context.Background(), history, storage.Task{}, false)
-	if err != nil {
-		t.Fatalf("Decide err: %v", err)
-	}
-	if dec.Phase != "propose" {
-		t.Errorf("Phase = %q, want propose", dec.Phase)
-	}
-	if dec.Draft.Repos[0] != "tools/calc" || dec.Draft.Repos[1] != "tools/ui" {
-		t.Errorf("Repos = %#v, want [tools/calc tools/ui]", dec.Draft.Repos)
-	}
-}
-
-// TestDecideProposeSteps — аналитик разложил задачу на этапы с критериями.
-func TestDecideProposeSteps(t *testing.T) {
-	a := &Analyst{Runner: &mockRunner{result: &opencode.Result{
-		RC:     0,
-		Stdout: `{"type":"text","part":{"text":"{\"phase\":\"propose\",\"title\":\"Калькулятор\",\"steps\":[{\"title\":\"Модель\",\"ac\":\"операции + - * /\"},{\"title\":\"UI\"}]}"}}`,
-	}}, Worktree: "/tmp"}
-
-	history := []core.Message{{Role: "user", Content: "Сделай калькулятор"}}
-	dec, err := a.Decide(context.Background(), history, storage.Task{}, false)
-	if err != nil {
-		t.Fatalf("Decide err: %v", err)
-	}
-	if dec.Phase != "propose" {
-		t.Errorf("Phase = %q, want propose", dec.Phase)
-	}
-	if len(dec.Draft.Steps) != 2 {
-		t.Fatalf("len(Steps) = %d, want 2", len(dec.Draft.Steps))
-	}
-	if dec.Draft.Steps[0].Title != "Модель" || dec.Draft.Steps[0].AC != "операции + - * /" {
-		t.Errorf("Steps[0] = %q/%q, want Модель/операции + - * /", dec.Draft.Steps[0].Title, dec.Draft.Steps[0].AC)
-	}
-	if dec.Draft.Steps[1].Title != "UI" || dec.Draft.Steps[1].AC != "" {
-		t.Errorf("Steps[1] = %q/%q, want UI/(пусто)", dec.Draft.Steps[1].Title, dec.Draft.Steps[1].AC)
-	}
-}
-
-// TestProposeOnlyStepsValid — propose меняет только steps → валидно.
-func TestProposeOnlyStepsValid(t *testing.T) {
-	a := &Analyst{Runner: &mockRunner{result: &opencode.Result{
-		RC:     0,
-		Stdout: `{"type":"text","part":{"text":"{\"phase\":\"propose\",\"steps\":[{\"title\":\"Шаг 1\"}],\"chat_reply\":\"Разбил на этапы\"}"}}`,
-	}}, Worktree: "/tmp"}
-
-	history := []core.Message{{Role: "user", Content: "test"}}
-	dec, err := a.Decide(context.Background(), history, storage.Task{}, false)
-	if err != nil {
-		t.Fatalf("Decide err: %v", err)
-	}
-	if dec.Phase != "propose" {
-		t.Errorf("Phase = %q, want propose", dec.Phase)
-	}
-	if len(dec.Draft.Steps) != 1 {
-		t.Fatalf("len(Steps) = %d, want 1", len(dec.Draft.Steps))
-	}
-}
-
-// TestFormatVerdict — человекочитаемое описание вердикта аналитика.
-func TestFormatVerdict(t *testing.T) {
-	tests := []struct {
-		name string
-		ar   *AnalystResponse
-		want []string
-	}{
-		{
-			name: "propose with fields",
-			ar: &AnalystResponse{
-				Phase:     "propose",
-				Title:     "Калькулятор",
-				Goal:      "Сделать веб-калькулятор",
-				Repos:     json.RawMessage(`["tools/calc","tools/ui"]`),
-				Why:       "Нужен для учёта",
-				AC:        "Работает + - * /",
-				ChatReply: "Готово!",
-			},
-			want: []string{
-				"phase=propose",
-				"chat_reply=Готово!",
-				"repos=[tools/calc, tools/ui]",
-				"title=Калькулятор",
-				"goal=Сделать веб-калькулятор",
-				"why=Нужен для учёта",
-				"ac=Работает + - * /",
-			},
-		},
-		{
-			name: "ask with questions",
-			ar: &AnalystResponse{
-				Phase:     "ask",
-				ChatReply: "Уточню",
-				Questions: []string{"Где код?", "Какая цель?"},
-			},
-			want: []string{"phase=ask", "chat_reply=Уточню", "questions=[Где код? | Какая цель?]"},
-		},
-		{
-			name: "abort with reason",
-			ar: &AnalystResponse{
-				Phase:       "abort",
-				AbortReason: "Тема не про код",
-			},
-			want: []string{"phase=abort", "abort_reason=Тема не про код"},
-		},
-		{
-			name: "empty verdict",
-			ar:   &AnalystResponse{},
-			want: []string{"phase="},
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := formatVerdict(tt.ar)
-			for _, w := range tt.want {
-				if !strings.Contains(got, w) {
-					t.Errorf("formatVerdict = %q, want contain %q", got, w)
-				}
-			}
-		})
-	}
-}
--- a/internal/analyst/prompt.go
+++ b/internal/analyst/prompt.go
@@ -3,8 +3,6 @@ package analyst
 import (
 	"strings"
 	"text/template"
-
-	"github.com/kamelion/ratatoskr-go/internal/storage"
 )

 // promptTemplate — шаблон промпта для аналитика (opencode analyst-agent).
@@ -25,7 +23,6 @@ var promptTemplate = template.Must(template.New("analyst").Parse(`Ты — ан
 | repos | список репозиториев (имена на git-хосте; для связанных — все сразу) |
 | why | зачем это нужно, контекст |
 | ac | acceptance criteria — конкретный результат, что считается готовым |
-| steps | (опционально) разбиение задачи на этапы: список {title, ac} с критерием готовности каждого этапа |

 Изменяй в JSON только те поля, которые надо поменять; что менять не надо — пустой строкой.

@@ -54,12 +51,6 @@ var promptTemplate = template.Must(template.New("analyst").Parse(`Ты — ан
 {{- else}}  repos: (не задано){{end}}
 {{if .Why}}  why: {{.Why}}{{else}}  why: (не задано){{end}}
 {{if .AC}}  ac: {{.AC}}{{else}}  ac: (не задано){{end}}
-{{if .Steps}}
-  steps:
-{{- range .Steps}}
-    - {{.Title}}{{if .AC}} → {{.AC}}{{end}}
-{{- end}}
-{{- else}}  steps: (не задано){{end}}

 **Ответь строго JSON-объектом, без лишнего текста:**
 {
@@ -69,7 +60,6 @@ var promptTemplate = template.Must(template.New("analyst").Parse(`Ты — ан
  "repos": ["имя_репо_1", "имя_репо_2"],
  "why": "зачем (только если меняешь)",
  "ac": "критерии (только если меняешь)",
-  "steps": [{"title": "этап 1", "ac": "критерий этапа 1"}],
  "questions": ["вопрос 1", "вопрос 2"],
  "chat_reply": "твой ответ пользователю (на русском, естественно)",
  "abort_reason": "если phase=abort — причина"
@@ -83,7 +73,6 @@ type TemplateData struct {
 	Repos   []string
 	Why     string
 	AC      string
-	Steps   []storage.Step
 	History string // отформатированная переписка
 	Force   bool
 }
--- a/internal/app/app.go
+++ b/internal/app/app.go
@@ -11,7 +11,6 @@ import (
 	"os/signal"
 	"path/filepath"
 	"strings"
-	"sync"
 	"syscall"
 	"time"

@@ -53,7 +52,7 @@ const packageOwner = "kamelion"
 // не следует путать с build-идентификатором `main.version` (commit-<sha7>),
 // который вшивается ldflag'ом и используется автообновлением. Здесь номер
 // поднимается вручную перед каждым релизом/публикацией новой сборки.
-const Version = "0.3.0"
+const Version = "0.2.2"

 // App — собранный конвейер.
 type App struct {
@@ -63,7 +62,7 @@ type App struct {
 	CoreCtx *core.Core
 	Worker  *worker.Worker
 	Updater *update.Updater
-	tg      *telegram.Channel // сохранена для Run (nil, если telegram.enabled=false)
+	tg      *telegram.Channel // сохранена для Run
 	pool    *opencode.Pool    // пул opencode serve-серверов (API-режим)

 	// Events — доменная шина UI; LogEvents — шина логов (панель «Логи»).
@@ -74,42 +73,6 @@ 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
-	mu       sync.Mutex             // защищает sessions (пишется из воркеров роутера)
-	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) {
-	f.mu.Lock()
-	sid := f.sessions[uid]
-	f.mu.Unlock()
-
-	res, err := f.Runner.Run(ctx, text, f.Worktree, "chat", sid)
-	if err != nil {
-		return "", err
-	}
-
-	f.mu.Lock()
-	f.sessions[uid] = res.SessionID
-	f.mu.Unlock()
-	return res.Stdout, nil
 }

 // New читает конфиг и собирает все зависимости.
@@ -156,6 +119,8 @@ func New(configPath, version, updateToken string, noUI bool) (*App, error) {
 	// Служебный root-сервер (worktree) живёт всё время app; остальные лениво.
 	ocPool := opencode.NewPool(cfg.Paths.Worktree)
 	ocPool.Bin = cfg.OpenCode.Bin
+	ocPool.Config = cfg.OpenCode.Config
+	ocPool.ConfigDir = cfg.OpenCode.ConfigDir
 	ocPool.DBPath = cfg.OpenCode.DBPath
 	ocPool.Host = cfg.OpenCode.Serve.Hostname
 	ocPool.BasePort = cfg.OpenCode.Serve.Port
@@ -222,15 +187,13 @@ func New(configPath, version, updateToken string, noUI bool) (*App, error) {
 		}
 	}

-	// Telegram-канал (если включён; иначе сетевые вызовы к Telegram не идут)
-	if cfg.Telegram.Enabled {
+	// Telegram-канал
 	tg := telegram.New(cfg.Telegram.Token, cfg.Chat.PollInterval.Duration())
 	a.tg = tg
 	if err := router.Attach(tg); err != nil {
 		store.Close()
 		return nil, fmt.Errorf("attach telegram: %w", err)
 	}
-	}

 	// Worker — polling-планировщик dev-агента
 	w := &worker.Worker{
@@ -249,9 +212,6 @@ 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}

@@ -291,15 +251,15 @@ func (a *App) Run(ctx context.Context) error {
 	}
 	defer a.pool.Close()

-	// Telegram: long-poll цикл в горутине (только если канал включён)
+	// Канал для проверки Telegram-ошибки (горутина оборачивает Run)
 	tgErr := make(chan error, 1)
-	if a.telegramChannel() != nil {
+
+	// Telegram: long-poll цикл в горутине
 	go func() {
 		tg := a.telegramChannel()
 		log.Print("app: telegram poll started")
 		tgErr <- tg.Run(ctx)
 	}()
-	}

 	// Worker: poll-цикл (неблокирующий — стартует свою горутину)
 	a.Worker.Start(ctx)
@@ -320,7 +280,6 @@ func (a *App) Run(ctx context.Context) error {
 	sigCh := make(chan os.Signal, 1)
 	signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)

-	if a.telegramChannel() != nil {
 	select {
 	case <-ctx.Done():
 		log.Print("app: context cancelled")
@@ -337,17 +296,6 @@ func (a *App) Run(ctx context.Context) error {
 	}
 }

-	select {
-	case <-ctx.Done():
-		log.Print("app: context cancelled")
-		return nil
-	case sig := <-sigCh:
-		log.Printf("app: signal %s — shutting down", sig)
-		cancel()
-		return nil
-	}
-}
-
 // telegramChannel возвращает Telegram-канал.
 func (a *App) telegramChannel() *telegram.Channel { return a.tg }

@@ -415,10 +363,6 @@ 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 — создать новую.")
 		}
@@ -483,26 +427,6 @@ 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 != "" {
@@ -663,21 +587,23 @@ func (a *App) handleUpdateCmd(ctx context.Context, uid chat.UserID) {
 	// сюда не возвращаемся — SwapAndRestart завершил процесс (os.Exit)
 }

-// ensureAgentsDir распаковывает встроенных агентов opencode (go:embed) в
-// project-каталог <worktree>/.opencode/agent/*.md. opencode при serve (cwd =
-// worktree) обнаруживает .opencode поднятием вверх (paths.ts) и сам находит
-// агентов. Глобальный конфиг opencode (модель/провайдеры) не трогаем и
-// OPENCODE_CONFIG_DIR не выставляем.
+// ensureAgentsDir определяет каталог с агентами opencode и распаковывает
+// туда встроенных агентов (go:embed). Если config_dir не задан — использует
+// ./agents рядом с бинарём. Встроенные агенты перезаписываются (всегда актуальны).
 //
 // idempotent: вызывается только из New.
 func ensureAgentsDir(cfg *config.Config) error {
-	if cfg.Paths.Worktree == "" {
-		return fmt.Errorf("paths.worktree не задан — некуда раскладывать агентов")
+	if cfg.OpenCode.ConfigDir == "" {
+		exe, err := os.Executable()
+		if err != nil {
+			return fmt.Errorf("resolve executable: %w", err)
 		}
-	base := filepath.Join(cfg.Paths.Worktree, ".opencode")
-	if err := agents.WriteTo(base); err != nil {
-		return fmt.Errorf("write agents to %s: %w", base, err)
+		// ./agents рядом с бинарём
+		cfg.OpenCode.ConfigDir = filepath.Join(filepath.Dir(exe), "agents")
 	}
-	log.Printf("app: agents ensured in %s", base)
+	if err := agents.WriteTo(cfg.OpenCode.ConfigDir); err != nil {
+		return fmt.Errorf("write agents to %s: %w", cfg.OpenCode.ConfigDir, err)
+	}
+	log.Printf("app: agents ensured in %s", cfg.OpenCode.ConfigDir)
 	return nil
 }
--- a/internal/chat/router.go
+++ b/internal/chat/router.go
@@ -21,35 +21,17 @@ type Router struct {
 	// Hook, вызываемый на каждое входящее событие (обычно → process_turn).
 	onUserMsg func(Incoming)

-	// Асинхронная обработка входящих ограниченным пулом воркеров с
-	// упорядоченными очередями per-user (см. chatWorkers, userState).
-	// Благодаря этому long-poll цикл канала (Telegram) не блокируется на время
-	// долгого вызова аналитика, а сообщения разных пользователей не сериализуются
-	// друг за другом: каждый активный пользователь занимает своего воркера.
-	jobs   chan *userState
-	users  map[UserID]*userState
-	userMu sync.Mutex
+	// Асинхронная обработка входящих: handleIncoming кладёт событие в канал,
+	// воркер-горутина последовательно вызывает onUserMsg. Благодаря этому
+	// long-poll цикл канала (Telegram) не блокируется на время долгого
+	// вызова аналитика и продолжает принимать новые сообщения.
+	incoming chan Incoming

 	// processed — число обработанных воркером событий (для синхронизации
 	// тестов с асинхронной очередью: WaitProcessed ждёт обработку события).
 	processed atomic.Int64
 }

-// userState — FIFO-очередь входящих одного пользователя. В каждый момент
-// для пользователя активен ровно один воркер (scheduled), поэтому порядок
-// обработки его сообщений сохраняется, а параллелизм достигается между
-// разными пользователями.
-type userState struct {
-	mu        sync.Mutex
-	pending   []Incoming
-	scheduled bool
-}
-
-// chatWorkers — число воркеров обработки входящих. Ограничивает количество
-// одновременных тяжёлых LLM-вызовов (аналитик/свободный чат), чтобы поток
-// каналов не упирался в один долгий вызов.
-const chatWorkers = 4
-
 // NewRouter создаёт роутер. onUserMsg — колбэк обработки входящего.
 func NewRouter(onUserMsg func(Incoming)) *Router {
 	if onUserMsg == nil {
@@ -60,51 +42,15 @@ func NewRouter(onUserMsg func(Incoming)) *Router {
 		routes:     map[UserID]Route{},
 		pending:    map[UserID]PendingQ{},
 		onUserMsg: onUserMsg,
-		jobs:      make(chan *userState, chatWorkers),
-		users:     make(map[UserID]*userState),
-	}
-	for i := 0; i < chatWorkers; i++ {
-		go r.workerLoop()
+		incoming:   make(chan Incoming, 256),
 	}
+	go r.processLoop()
 	return r
 }

-// userStateOf возвращает очередь пользователя (создаёт при первом сообщении).
-// Очереди живут вечно — по одной маленькой структуре на пользователя/вкладку.
-func (r *Router) userStateOf(uid UserID) *userState {
-	r.userMu.Lock()
-	defer r.userMu.Unlock()
-	st, ok := r.users[uid]
-	if !ok {
-		st = &userState{}
-		r.users[uid] = st
-	}
-	return st
-}
-
-// workerLoop — воркер пула: берёт пользователя из общей очереди и дренит его.
-func (r *Router) workerLoop() {
-	for st := range r.jobs {
-		r.runUser(st)
-	}
-}
-
-// runUser обрабатывает все накопленные сообщения пользователя по порядку.
-// По исчерпании очереди снимает scheduled — следующий handleIncoming вновь
-// поставит пользователя в jobs. Возвращается в workerLoop, чтобы тот взял
-// следующего пользователя из общей очереди.
-func (r *Router) runUser(st *userState) {
-	for {
-		st.mu.Lock()
-		if len(st.pending) == 0 {
-			st.scheduled = false
-			st.mu.Unlock()
-			return
-		}
-		inc := st.pending[0]
-		st.pending = st.pending[1:]
-		st.mu.Unlock()
-
+// processLoop — воркер асинхронной обработки входящих (FIFO).
+func (r *Router) processLoop() {
+	for inc := range r.incoming {
 		r.onUserMsg(inc)
 		r.processed.Add(1)
 	}
@@ -153,19 +99,9 @@ func (r *Router) handleIncoming(inc Incoming) {
 	}
 	r.mu.Unlock()

-	// Асинхронная обработка: кладём событие в FIFO-очередь пользователя и
-	// сразу возвращаемся, не блокируя вызывающий long-poll цикл канала.
-	// Если пользователь ещё не обрабатывается — ставим его в общую очередь
-	// пула воркеров. Backpressure по jobs блокирует только перегруженного
-	// пользователя (его собственную горутину канала), не весь роутер.
-	st := r.userStateOf(inc.UserID)
-	st.mu.Lock()
-	st.pending = append(st.pending, inc)
-	if !st.scheduled {
-		st.scheduled = true
-		r.jobs <- st
-	}
-	st.mu.Unlock()
+	// Асинхронная обработка: кладём событие в очередь воркера и сразу
+	// возвращаемся, не блокируя вызывающий long-poll цикл канала.
+	r.incoming <- inc
 }

 // Send уведомляет пользователя через текущий маршрут. M1 (нет маршрута) — no-op,
--- a/internal/chat/router_test.go
+++ b/internal/chat/router_test.go
@@ -213,105 +213,3 @@ func TestRouter_Ask_PendingNotConsumedFromOtherAddr(t *testing.T) {
 		t.Fatal("pending должен остаться (ответ из другого адреса)")
 	}
 }
-
-// TestRouter_PerUserOrdering проверяет, что сообщения одного пользователя
-// обрабатываются строго в порядке поступления (пул воркеров не перемешивает).
-func TestRouter_PerUserOrdering(t *testing.T) {
-	cb := newFakeOnMsg()
-	r := NewRouter(cb.h)
-	tgCh := newFakeChannel(tg)
-	_ = r.Attach(tgCh)
-
-	for _, txt := range []string{"1", "2", "3"} {
-		tgCh.emit(uidA, tg, txt)
-	}
-	if !cb.wait(3) {
-		t.Fatal("сообщения не обработаны за таймаут")
-	}
-	for i, want := range []string{"1", "2", "3"} {
-		if got := cb.get(i).Msg.Text; got != want {
-			t.Errorf("порядок обработки нарушен: idx %d = %q, want %q", i, got, want)
-		}
-	}
-}
-
-// TestRouter_ParallelismAcrossUsers проверяет, что пока обработчик одного
-// пользователя заблокирован (долгий LLM-вызов), сообщение другого пользователя
-// обрабатывается в другом воркере, а второе сообщение того же пользователя —
-// ждёт своей очереди (per-user порядок).
-func TestRouter_ParallelismAcrossUsers(t *testing.T) {
-	r := NewRouter(nil)
-
-	tgCh := newFakeChannel(tg)
-	tuiCh := newFakeChannel(tui)
-	_ = r.Attach(tgCh)
-	_ = r.Attach(tuiCh)
-
-	blocked := make(chan struct{})
-	release := make(chan struct{})
-	var muLocal sync.Mutex
-	seen := make([]string, 0, 3)
-	signal := make(chan struct{}, 8)
-
-	h := func(inc Incoming) {
-		if inc.Msg.Text == "block" {
-			close(blocked)
-			<-release // держим воркера, пока не отпустим
-		}
-		muLocal.Lock()
-		seen = append(seen, inc.Msg.Text)
-		muLocal.Unlock()
-		signal <- struct{}{}
-	}
-	r.onUserMsg = h
-
-	snapshot := func() []string {
-		muLocal.Lock()
-		defer muLocal.Unlock()
-		return append([]string(nil), seen...)
-	}
-	waitFor := func(n int) bool {
-		deadline := time.After(2 * time.Second)
-		for len(snapshot()) < n {
-			select {
-			case <-signal:
-			case <-deadline:
-				return false
-			}
-		}
-		return true
-	}
-
-	// первое сообщение A блокирует своего воркера
-	tgCh.emit(uidA, tg, "block")
-	<-blocked
-
-	// B обрабатывается параллельно, пока A висит
-	tuiCh.emit(uidB, tui, "B1")
-	select {
-	case <-signal:
-	case <-time.After(100 * time.Millisecond):
-		t.Fatal("B не обработан, пока блокирован A — чат-путь снова сериализован")
-	}
-	if got := snapshot(); len(got) != 1 || got[0] != "B1" {
-		t.Fatalf("ожидали обработку B1, got %v", got)
-	}
-
-	// второе сообщение A НЕ обрабатывается, пока занят воркер A (порядок per-user)
-	tgCh.emit(uidA, tg, "a2")
-	select {
-	case <-signal:
-		t.Fatal("сообщение A обработано ДО освобождения A — нарушен per-user порядок")
-	case <-time.After(80 * time.Millisecond):
-	}
-
-	// отпускаем A → дообрабатывается a2
-	close(release)
-	if !waitFor(3) {
-		t.Fatal("итоговые сообщения не обработаны")
-	}
-	got := snapshot()
-	if got[2] != "a2" {
-		t.Errorf("порядок персональной очереди нарушен: pos2 = %q, want a2", got[2])
-	}
-}
--- a/internal/config/config_test.go
+++ b/internal/config/config_test.go
@@ -146,6 +146,54 @@ log:
 	}
 }

+func TestLoad_OpenCodeConfigDir(t *testing.T) {
+	t.Setenv("TG_TOKEN", "tok")
+	t.Setenv("TG_CHAT_ID", "42")
+
+	// без config_dir — пусто
+	yaml := `telegram:
+  token: "${TG_TOKEN}"
+  chat_id: "${TG_CHAT_ID}"
+`
+	cfg, err := Load(writeCfg(t, yaml))
+	if err != nil {
+		t.Fatalf("Load: %v", err)
+	}
+	if cfg.OpenCode.ConfigDir != "" {
+		t.Errorf("config_dir = %q, want пусто", cfg.OpenCode.ConfigDir)
+	}
+
+	// через env OPENCODE_CONFIG_DIR
+	t.Setenv("OPENCODE_CONFIG_DIR", "/opt/agents")
+	cfg, err = Load(writeCfg(t, yaml))
+	if err != nil {
+		t.Fatalf("Load: %v", err)
+	}
+	if cfg.OpenCode.ConfigDir != "/opt/agents" {
+		t.Errorf("config_dir = %q, want /opt/agents", cfg.OpenCode.ConfigDir)
+	}
+}
+
+func TestLoad_EnvOverride(t *testing.T) {
+	t.Setenv("TG_TOKEN", "tok")
+	t.Setenv("TG_CHAT_ID", "42")
+	// env override для opencode.timeout
+	t.Setenv("OPENCODE_CONFIG", "/custom/opencode.json")
+
+	yaml := `telegram:
+  token: "${TG_TOKEN}"
+  chat_id: "${TG_CHAT_ID}"
+`
+	path := writeCfg(t, yaml)
+	cfg, err := Load(path)
+	if err != nil {
+		t.Fatalf("Load: %v", err)
+	}
+	if cfg.OpenCode.Config != "/custom/opencode.json" {
+		t.Errorf("opencode config = %q", cfg.OpenCode.Config)
+	}
+}
+
 func TestLoad_MissingEnvVarUsesDefault(t *testing.T) {
 	t.Setenv("TG_TOKEN", "tok")
 	t.Setenv("TG_CHAT_ID", "42")
@@ -229,7 +277,7 @@ paths:
 }

 func TestLoad_MissingRequired(t *testing.T) {
-	// пустой конфиг — все обязательные поля отсутствуют (telegram.enabled по дефолту true)
+	// пустой конфиг — все обязательные поля отсутствуют
 	t.Setenv("TG_TOKEN", "")
 	t.Setenv("TG_CHAT_ID", "")

@@ -250,41 +298,6 @@ func TestLoad_MissingRequired(t *testing.T) {
 	}
 }

-func TestLoad_TelegramDisabledSkipsToken(t *testing.T) {
-	// enabled: false — token/chat_id не обязательны, конфиг валиден
-	t.Setenv("TG_TOKEN", "")
-	t.Setenv("TG_CHAT_ID", "")
-
-	yaml := `telegram:
-  enabled: false
-  token: ""
-  chat_id: ""
-`
-	path := writeCfg(t, yaml)
-	cfg, err := Load(path)
-	if err != nil {
-		t.Fatalf("Load: %v", err)
-	}
-	if cfg.Telegram.Enabled {
-		t.Error("telegram.enabled = true, want false")
-	}
-}
-
-func TestLoad_TelegramEnabledDefaultTrue(t *testing.T) {
-	// enabled не задан — дефолт true, token обязателен
-	t.Setenv("TG_TOKEN", "")
-	t.Setenv("TG_CHAT_ID", "42")
-
-	yaml := `telegram:
-  chat_id: "42"
-`
-	path := writeCfg(t, yaml)
-	_, err := Load(path)
-	if err == nil || !strings.Contains(err.Error(), "telegram.token") {
-		t.Errorf("ожидалась ошибка telegram.token (enabled по дефолту true), got %v", err)
-	}
-}
-
 func TestLoad_InvalidDuration(t *testing.T) {
 	t.Setenv("TG_TOKEN", "x")
 	t.Setenv("TG_CHAT_ID", "x")
--- a/internal/config/load.go
+++ b/internal/config/load.go
@@ -35,10 +35,6 @@ func Load(path string) (*Config, error) {
 		}
 	}
 	cfg := &Config{}
-	// Telegram по умолчанию включён (если в YAML не указан enabled).
-	// Делаем до unmarshal: yaml.Unmarshal перезапишет поле, только если ключ
-	// есть в документе, поэтому отсутствующий enabled останется true.
-	cfg.Telegram.Enabled = true
 	if !noFile {
 		expanded := os.Expand(string(raw), envLookup)
 		if err := yaml.Unmarshal([]byte(expanded), cfg); err != nil {
--- a/internal/config/types.go
+++ b/internal/config/types.go
@@ -76,11 +76,7 @@ type UpdateCfg struct {
 	CheckInterval Duration `yaml:"check_interval" default:"24h"`
 }

-// TelegramCfg — настройки Telegram-канала. Enabled=false отключает канал
-// полностью: бот не опрашивается, сетевые вызовы к api.telegram.org не идут,
-// token/chat_id не обязательны. По умолчанию включён (см. Load: presetTelegramEnabled).
 type TelegramCfg struct {
-	Enabled bool   `yaml:"enabled"`
 	Token  string `yaml:"token"  env:"TG_TOKEN"`
 	ChatID string `yaml:"chat_id" env:"TG_CHAT_ID"`
 }
@@ -88,6 +84,8 @@ type TelegramCfg struct {
 type OpenCodeCfg struct {
 	Bin         string   `yaml:"bin"           default:"opencode"`
 	DBPath      string   `yaml:"db_path"       default:""`
+	Config      string   `yaml:"config"        env:"OPENCODE_CONFIG"`
+	ConfigDir   string   `yaml:"config_dir"    env:"OPENCODE_CONFIG_DIR"`
 	HardTimeout Duration `yaml:"hard_timeout"   default:"20m"`
 	IdleTimeout Duration `yaml:"idle_timeout"   default:"5m"`
 	PollMs      Duration `yaml:"poll_ms"        default:"2s"`
@@ -123,14 +121,12 @@ type PathsCfg struct {
 // (склеенную, все ошибки сразу) или C2 InvalidFormat.
 func (c *Config) Validate() error {
 	var errs []error
-	if c.Telegram.Enabled {
 	if c.Telegram.Token == "" {
 		errs = append(errs, fmt.Errorf("%w: telegram.token", ErrMissingField))
 	}
 	if c.Telegram.ChatID == "" {
 		errs = append(errs, fmt.Errorf("%w: telegram.chat_id", ErrMissingField))
 	}
-	}
 	if !c.Log.Debug() && !strings.EqualFold(c.Log.Level, "info") {
 		errs = append(errs, fmt.Errorf("%w: log.level (ожидается \"info\" или \"debug\")", ErrInvalidFormat))
 	}
--- a/internal/core/core.go
+++ b/internal/core/core.go
@@ -228,11 +228,6 @@ func (c *Core) handleRetry(ctx context.Context, rest string) (Result, error) {
 	if err := c.Store.ClearHistory(ctx, id); err != nil {
 		return Result{}, err
 	}
-	// Чистый перезапуск: сбрасываем маркер постмортем-анализа от прошлого
-	// прогона, чтобы на новом failed/timeout постмортем запустился заново.
-	if err := c.Store.DeleteTracesByAgent(ctx, id, "postmortem"); err != nil {
-		return Result{}, err
-	}
 	return Result{
 		Reply:  "Задача перезапущена. Опишите, что меняем:",
 		TaskID: id,
--- a/internal/events/log.go
+++ b/internal/events/log.go
@@ -5,14 +5,6 @@ import (
 	"sync"
 )

-// Канонические уровни записей лога (фильтр панели «Логи», см. ui.LogLevels).
-const (
-	LevelError   = "error"
-	LevelWarning = "warning"
-	LevelInfo    = "info"
-	LevelDebug   = "debug"
-)
-
 // LogLine — строка лога для панели «Логи».
 type LogLine struct {
 	Level string
@@ -21,37 +13,6 @@ type LogLine struct {

 func (LogLine) _event() {}

-// markers проверяет наличие любого из маркеров в уже приведённой к нижнему
-// регистру строке.
-func markers(s string, anyOf ...string) bool {
-	for _, m := range anyOf {
-		if strings.Contains(s, m) {
-			return true
-		}
-	}
-	return false
-}
-
-// ClassifyLevel определяет уровень строки лога по её тексту.
-//
-// Стандартный log.Printf не несёт уровня, поэтому применяются эвристики по
-// маркерам в тексте (в приоритете debug → warning → error): "debug"/"trace" —
-// отладка; "warn"/"предупреж" — предупреждение; "error"/"ошибк"/"failed"/
-// "fatal"/"panic" — ошибка. Остальные строки — информационные.
-func ClassifyLevel(line string) string {
-	s := strings.ToLower(line)
-	switch {
-	case markers(s, "debug", "trace"):
-		return LevelDebug
-	case markers(s, "warn", "предупреж"):
-		return LevelWarning
-	case markers(s, "error", "ошибк", "failed", "failure", "fatal", "panic"):
-		return LevelError
-	default:
-		return LevelInfo
-	}
-}
-
 // LogBus — тип-обёртка над *Bus для логов.
 //
 // Логи идут отдельной шиной, чтобы большие объёмы текста не блокировали
@@ -74,8 +35,7 @@ type LogWriter struct {
 	buf strings.Builder
 }

-// NewLogWriter создаёт LogWriter, публикующий строки лога как события
-// LogLine; уровень каждой строки определяется эвристикой ClassifyLevel.
+// NewLogWriter создаёт LogWriter, публикующий в шину логов события LogLine{Level:"log"}.
 func NewLogWriter(bus *LogBus) *LogWriter {
 	return &LogWriter{bus: bus.Bus}
 }
@@ -96,7 +56,7 @@ func (w *LogWriter) Write(p []byte) (int, error) {
 		line := strings.TrimSuffix(data[:idx], "\r")
 		data = data[idx+1:]
 		if line != "" {
-			w.bus.Publish(LogLine{Level: ClassifyLevel(line), Text: line})
+			w.bus.Publish(LogLine{Level: "log", Text: line})
 		}
 	}
 	w.buf.Reset()
--- a/internal/events/log_test.go
+++ b/internal/events/log_test.go
@@ -21,8 +21,7 @@ func TestLogWriterLines(t *testing.T) {
 	if !ok {
 		t.Fatalf("got %T, want LogLine", first)
 	}
-	// строка без маркеров ошибок/отладки — информационная
-	if ll.Text != "first line" || ll.Level != LevelInfo {
+	if ll.Text != "first line" || ll.Level != "log" {
 		t.Fatalf("unexpected first line: %+v", ll)
 	}

@@ -75,50 +74,3 @@ func TestLogWriterMultiSplit(t *testing.T) {
 		t.Fatalf("got %v", texts)
 	}
 }
-
-// ClassifyLevel определяет уровень строки по маркерам в тексте.
-func TestClassifyLevel(t *testing.T) {
-	cases := []struct {
-		line string
-		want string
-	}{
-		{"app: db opened /tmp/r.db", LevelInfo},
-		{"app: worker started", LevelInfo},
-		{"opencode: debug: poll request", LevelDebug},
-		{"opencode api debug: prompt -> POST http://127.0.0.1:4096/api/session", LevelDebug},
-		{"opencode api debug: messages response (512 bytes)", LevelDebug},
-		{"trace: session resumed", LevelDebug},
-		{"tg: warn: long poll timeout", LevelWarning},
-		{"ПРЕДУПРЕЖДЕНИЕ: конфиг не задан", LevelWarning},
-		{"app: process /start #5: run failed: exit status 1", LevelError},
-		{"ERROR: connection refused", LevelError},
-		{"worker: job failed after 3 retries", LevelError},
-		{"panic: runtime error", LevelError},
-	}
-	for _, c := range cases {
-		if got := ClassifyLevel(c.line); got != c.want {
-			t.Errorf("ClassifyLevel(%q) = %q, want %q", c.line, got, c.want)
-		}
-	}
-}
-
-// LogWriter публикует уровень, определённый по тексту строки.
-func TestLogWriterClassifiesLevels(t *testing.T) {
-	lbus := NewLogBus(16)
-	ch, unsub := lbus.Subscribe()
-	defer unsub()
-
-	w := NewLogWriter(lbus)
-	if _, err := w.Write([]byte("all good\nERROR: boom\n")); err != nil {
-		t.Fatalf("Write: %v", err)
-	}
-
-	first := receiveOne(t, ch).(LogLine)
-	if first.Level != LevelInfo || first.Text != "all good" {
-		t.Fatalf("unexpected first: %+v", first)
-	}
-	second := receiveOne(t, ch).(LogLine)
-	if second.Level != LevelError || second.Text != "ERROR: boom" {
-		t.Fatalf("unexpected second: %+v", second)
-	}
-}
--- a/internal/opencode/client.go
+++ b/internal/opencode/client.go
@@ -6,8 +6,8 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
+	"log"
 	"net/http"
-	"strings"
 	"time"
 )

@@ -26,18 +26,10 @@ import (
 type Client struct {
 	BaseURL  string // http://host:port (без завершающего слеша)
 	Password string // basic auth (username "opencode")
-	Directory string       // каталог сервера — идёт заголовком x-opencode-directory
 	Debug    bool   // включать отладочные логи API-вызовов (log.level=debug)
 	http     *http.Client // единый клиент: все операции быстрые (нет блокирующего Send)
 }

-// SessionMessagesURL возвращает URL для просмотра сообщений сессии в браузере.
-// Сортировка по времени: сначала новые (order=desc). Без credentials — пароль
-// в лог не попадает.
-func SessionMessagesURL(baseURL, sessionID string) string {
-	return baseURL + "/api/session/" + sessionID + "/message?order=desc"
-}
-
 // ClientErr — классы ошибок клиента.
 type ClientErr struct {
 	Op  string // "connect" | "create" | "prompt" | "messages" | "active" | "abort"
@@ -64,15 +56,17 @@ func (c *Client) do(ctx context.Context, method, path, op string, body []byte) (
 	if err != nil {
 		return nil, &ClientErr{Op: "connect", Err: err}
 	}
-	if body != nil {
-		req.ContentLength = int64(len(body))
-	}
 	if c.Password != "" {
 		req.SetBasicAuth("opencode", c.Password)
 	}
+	if body != nil {
 		req.Header.Set("Content-Type", "application/json")
-	if c.Directory != "" {
-		req.Header.Set("x-opencode-directory", c.Directory)
+	}
+	if c.Debug {
+		log.Printf("opencode api %s -> %s %s%s", op, method, c.BaseURL, path)
+		if len(body) > 0 {
+			log.Printf("opencode api %s request body: %s", op, truncateStr(string(body), 5000))
+		}
 	}
 	resp, err := c.http.Do(req)
 	if err != nil {
@@ -84,8 +78,14 @@ func (c *Client) do(ctx context.Context, method, path, op string, body []byte) (
 		return nil, &ClientErr{Op: "connect", Err: err}
 	}
 	if resp.StatusCode < 200 || resp.StatusCode > 299 {
+		if c.Debug {
+			log.Printf("opencode api %s response: status %d: %s", op, resp.StatusCode, truncateStr(string(b), 1000))
+		}
 		return nil, &ClientErr{Op: op, Err: fmt.Errorf("status %d: %s", resp.StatusCode, truncateStr(string(b), 300))}
 	}
+	if c.Debug {
+		log.Printf("opencode api %s response (%d bytes): %s", op, len(b), truncateStr(string(b), 5000))
+	}
 	return b, nil
 }

@@ -97,7 +97,7 @@ type ModelRef struct {
 	Variant    string `json:"variant,omitempty"`
 }

-// String возвращает каноническое представление "provider/id[/variant]".
+// String возвращает каноничное представление "provider/id[/variant]".
 func (m *ModelRef) String() string {
 	if m == nil {
 		return ""
@@ -108,14 +108,13 @@ func (m *ModelRef) String() string {
 	return m.ProviderID + "/" + m.ID
 }

-// CreateSession создаёт новую сессию и возвращает её id. agent — имя агента
-// (analyst/dev/reviewer/chat/postmortem) из встроенных определений ratatoskr.
-// Модель мы НЕ выбираем: opencode сам берёт модель по умолчанию из своего
-// глобального конфига (ratatoskr про неё ничего не знает).
-func (c *Client) CreateSession(ctx context.Context, agent string) (string, error) {
+// CreateSession создаёт новую сессию и возвращает её id. model != nil —
+// хардпин модели (top-level "model" из конфига opencode), чтобы не зависеть
+// от fallback-логики выбора модели в самом opencode.
+func (c *Client) CreateSession(ctx context.Context, model *ModelRef) (string, error) {
 	payload := map[string]any{}
-	if agent != "" {
-		payload["agent"] = agent
+	if model != nil {
+		payload["model"] = model
 	}
 	body, _ := json.Marshal(payload)
 	raw, err := c.do(ctx, http.MethodPost, "/api/session", "create", body)
@@ -133,12 +132,6 @@ func (c *Client) CreateSession(ctx context.Context, agent string) (string, error
 	if out.Data.ID == "" {
 		return "", &ClientErr{Op: "create", Err: fmt.Errorf("пустой id сессии")}
 	}
-	time.Sleep(2 * time.Second)
-	// Холостой вызов /api/model: прогревает сервер (модель/провайдеры),
-	// чтобы первый промпт не спотыкался о «тёплый» старт.
-	_, _ = c.do(ctx, http.MethodGet, "/api/model", "models-warmup", nil)
-	time.Sleep(2 * time.Second)
-	_, _ = c.do(ctx, http.MethodGet, "/api/model", "models-warmup", nil)
 	return out.Data.ID, nil
 }

@@ -330,79 +323,6 @@ func assistantText(msgs []v2Message, since int64) []string {
 	return texts
 }

-// assistantVerdict собирает финальный текст ответа: сначала text-парты, а если
-// их нет — только reasoning-парты (fallback для моделей, которые на некоторые
-// запросы отвечают лишь reasoning без text). usedReasoning=true означает, что
-// text-партов не было вовсе и вердикт собран из reasoning.
-func assistantVerdict(msgs []v2Message, since int64) (texts []string, usedReasoning bool) {
-	if texts := assistantText(msgs, since); len(texts) > 0 {
-		return texts, false
-	}
-	ass := assistantSince(msgs, since)
-	reasoning := make([]string, 0, len(ass))
-	for i := len(ass) - 1; i >= 0; i-- {
-		for _, p := range ass[i].Content {
-			if p.Type == "reasoning" && p.Text != "" {
-				reasoning = append(reasoning, p.Text)
-			}
-		}
-	}
-	return reasoning, len(reasoning) > 0
-}
-
-// transcriptRole возвращает человекочитаемую подпись роли сообщения сессии.
-func transcriptRole(t string) string {
-	switch t {
-	case "user":
-		return "Пользователь"
-	case "assistant":
-		return "Ассистент"
-	case "tool":
-		return "Инструмент"
-	case "system":
-		return "Система"
-	default:
-		return t
-	}
-}
-
-// finishLabel — подпись для finish-reason (пусто/: опускаем).
-func finishLabel(f string) string {
-	if f == "" || f == "stop" {
-		return ""
-	}
-	return f
-}
-
-// renderTranscript форматирует сообщения сессии (API отдаёт новыми первыми)
-// в хронологическом порядке: роль, текст (и tool-вызовы), с обрезкой.
-func renderTranscript(msgs []v2Message) string {
-	var b strings.Builder
-	for i := len(msgs) - 1; i >= 0; i-- {
-		m := &msgs[i]
-		b.WriteString("\n== " + transcriptRole(m.Type))
-		if m.Type == "assistant" {
-			if m.Model != nil {
-				b.WriteString(" (" + m.Model.String() + ")")
-			}
-			if fl := finishLabel(m.Finish); fl != "" {
-				b.WriteString(" finish=" + fl)
-			}
-		}
-		b.WriteString(" ==\n")
-		for _, p := range m.Content {
-			if p.Text == "" {
-				continue
-			}
-			b.WriteString(p.Text)
-			if !strings.HasSuffix(p.Text, "\n") {
-				b.WriteString("\n")
-			}
-		}
-	}
-	return b.String()
-}
-
 func truncateStr(s string, n int) string {
 	if len(s) <= n {
 		return s
--- a/internal/opencode/client_test.go
+++ b/internal/opencode/client_test.go
@@ -28,10 +28,9 @@ type fakeAPIServer struct {
 	blockPrompt bool
 	messages   []v2Message
 	verdictText string
-	verdictReasoning string // завершённый ответ только с reasoning-партом (без text)
 	failCreate  bool
 	failMessages bool
-	createdAgent string // агент, полученный на POST /api/session
+	createdModel *ModelRef // модель, полученная на POST /api/session
 	promptCalls int

 	// streamGrow: стрим одного растущего парта — текст/reasoning растёт с
@@ -55,10 +54,10 @@ func (f *fakeAPIServer) handler() http.Handler {
 			return
 		}
 		var in struct {
-			Agent string `json:"agent"`
+			Model *ModelRef `json:"model"`
 		}
 		_ = json.NewDecoder(r.Body).Decode(&in)
-		f.createdAgent = in.Agent
+		f.createdModel = in.Model
 		f.sessionID = "sess-fake"
 		f.created = true
 		writeJSON(w, map[string]any{"data": map[string]any{"id": "sess-fake"}})
@@ -134,9 +133,6 @@ func (f *fakeAPIServer) handler() http.Handler {
 		if msgs == nil && f.verdictText != "" && !f.blockPrompt {
 			msgs = []v2Message{f.assistantMsg(f.verdictText)}
 		}
-		if msgs == nil && f.verdictReasoning != "" && !f.blockPrompt {
-			msgs = []v2Message{f.assistantReasoningMsg(f.verdictReasoning)}
-		}
 		if msgs == nil {
 			msgs = []v2Message{}
 		}
@@ -157,19 +153,6 @@ func (f *fakeAPIServer) assistantMsg(text string) v2Message {
 	}
 }

-// assistantReasoningMsg строит завершённое assistant-сообщение только с
-// reasoning-партом (без text) — для проверки fallback-сценария.
-func (f *fakeAPIServer) assistantReasoningMsg(text string) v2Message {
-	now := time.Now().UnixMilli()
-	return v2Message{
-		ID:      "msg_r",
-		Type:    "assistant",
-		Content: []v2Part{{Type: "reasoning", Text: text}},
-		Finish:  "end_turn",
-		Time:    v2Time{Created: &now, Completed: &now},
-	}
-}
-
 func writeJSON(w http.ResponseWriter, v any) {
 	w.Header().Set("Content-Type", "application/json")
 	_ = json.NewEncoder(w).Encode(v)
@@ -186,43 +169,33 @@ func fakeClient(t *testing.T, f *fakeAPIServer) *Client {
 func TestClient_CreateSession(t *testing.T) {
 	f := &fakeAPIServer{}
 	c := fakeClient(t, f)
-	id, err := c.CreateSession(context.Background(), "dev")
+	id, err := c.CreateSession(context.Background(), nil)
 	if err != nil {
 		t.Fatalf("CreateSession err: %v", err)
 	}
 	if id != "sess-fake" {
 		t.Errorf("id = %q, want sess-fake", id)
 	}
-	if f.createdAgent != "dev" {
-		t.Errorf("createdAgent = %q, want dev", f.createdAgent)
+	if f.createdModel != nil {
+		t.Errorf("createdModel = %+v, want nil", f.createdModel)
 	}
 }

-func TestClient_CreateSessionPassesAgent(t *testing.T) {
+func TestClient_CreateSessionHardpinsModel(t *testing.T) {
+	want := &ModelRef{ProviderID: "tokentool", ID: "deepseek/deepseek-v4-flash-0731"}
 	f := &fakeAPIServer{}
 	c := fakeClient(t, f)
-	if _, err := c.CreateSession(context.Background(), "postmortem"); err != nil {
+	if _, err := c.CreateSession(context.Background(), want); err != nil {
 		t.Fatalf("CreateSession err: %v", err)
 	}
-	if f.createdAgent != "postmortem" {
-		t.Errorf("createdAgent = %q, want postmortem", f.createdAgent)
-	}
-}
-
-func TestClient_CreateSessionNoAgent(t *testing.T) {
-	f := &fakeAPIServer{}
-	c := fakeClient(t, f)
-	if _, err := c.CreateSession(context.Background(), ""); err != nil {
-		t.Fatalf("CreateSession err: %v", err)
-	}
-	if f.createdAgent != "" {
-		t.Errorf("createdAgent = %q, want пусто", f.createdAgent)
+	if f.createdModel == nil || f.createdModel.ProviderID != want.ProviderID || f.createdModel.ID != want.ID {
+		t.Errorf("createdModel = %+v, want %+v", f.createdModel, want)
 	}
 }

 func TestClient_CreateSessionFail(t *testing.T) {
 	c := fakeClient(t, &fakeAPIServer{failCreate: true})
-	if _, err := c.CreateSession(context.Background(), "dev"); err == nil {
+	if _, err := c.CreateSession(context.Background(), nil); err == nil {
 		t.Fatal("CreateSession должен упасть при 500, а не nil")
 	}
 }
@@ -306,45 +279,16 @@ func Test_newestAssistant(t *testing.T) {
 	}
 }

-func Test_assistantVerdict(t *testing.T) {
-	older := time.Now().Add(-time.Minute).UnixMilli()
-	newer := time.Now().UnixMilli()
-	reasoningOf := func(text string, at *int64) v2Message {
-		return v2Message{ID: "r", Type: "assistant", Content: []v2Part{{Type: "reasoning", Text: text}}, Time: v2Time{Created: at}}
+func Test_parseModelString(t *testing.T) {
+	m := parseModelString("tokentool/deepseek/deepseek-v4-flash-0731")
+	if m == nil || m.ProviderID != "tokentool" || m.ID != "deepseek/deepseek-v4-flash-0731" {
+		t.Errorf("parse = %+v, want tokentool/deepseek-v4-flash-0731", m)
 	}
-
-	// reasoning-only: text-партов нет → fallback на reasoning, usedReasoning=true.
-	// Сообщения приходят новейшими первыми (как из API) → размышление 2 новее.
-	reasoningOnlyMsgs := []v2Message{
-		reasoningOf("размышление 2", &newer),
-		reasoningOf("размышление 1", &older),
+	if parseModelString("onlyprovider") != nil {
+		t.Error("parse без '/' должен вернуть nil")
 	}
-	texts, used := assistantVerdict(reasoningOnlyMsgs, older)
-	if !used {
-		t.Error("usedReasoning = false, want true для reasoning-only")
-	}
-	if len(texts) != 2 || texts[0] != "размышление 1" || texts[1] != "размышление 2" {
-		t.Errorf("verdict = %v, want [размышление 1 размышление 2] (хронологически)", texts)
-	}
-
-	// text + reasoning → берётся text, reasoning игнорируется.
-	mixed := []v2Message{
-		{ID: "a", Type: "assistant",
-			Content: []v2Part{{Type: "reasoning", Text: "thinking"}, {Type: "text", Text: "ответ"}},
-			Time:     v2Time{Created: &newer}},
-	}
-	texts, used = assistantVerdict(mixed, older)
-	if used {
-		t.Error("usedReasoning = true, want false (есть text)")
-	}
-	if len(texts) != 1 || texts[0] != "ответ" {
-		t.Errorf("verdict = %v, want [ответ]", texts)
-	}
-
-	// пусто → пусто и usedReasoning=false.
-	empty := []v2Message{{ID: "u", Type: "user", Time: v2Time{Created: &newer}}}
-	if texts, used := assistantVerdict(empty, older); used || len(texts) != 0 {
-		t.Errorf("пусто: texts=%v usedReasoning=%v, want пусто/false", texts, used)
+	if parseModelString("") != nil {
+		t.Error("parse пустой должен вернуть nil")
 	}
 }

@@ -355,12 +299,3 @@ func TestClientErr_Unwrap(t *testing.T) {
 		t.Fatal("expected *ClientErr")
 	}
 }
-
-// TestSessionMessagesURL — ссылка на сообщения сессии, сортировка по времени (новые сверху).
-func TestSessionMessagesURL(t *testing.T) {
-	got := SessionMessagesURL("http://127.0.0.1:4101", "sess-abc")
-	want := "http://127.0.0.1:4101/api/session/sess-abc/message?order=desc"
-	if got != want {
-		t.Errorf("SessionMessagesURL() = %q, want %q", got, want)
-	}
-}
--- a/internal/opencode/config.go
+++ b/internal/opencode/config.go
@@ -0,0 +1,176 @@
+package opencode
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// Чтение top-level "model" из эффективного конфига opencode.
+//
+// Зачем: ratatoskr хардпинит модель в сессии (CreateSession), чтобы не зависеть
+// от fallback-логики opencode. Если в конфиге модель не задана (или конфиг
+// написан по старой v1-схеме — npm/options, которые v2 молча игнорирует),
+// opencode сам выберет «дефолтную» модельную запись, и это может оказаться не
+// той моделью. Поэтому мы явно логируем предупреждение (класс O5 WARN).
+
+// opencodeConfigPath определяет путь к конфигу opencode, который видит
+// serve-процесс этого пула (см. README): (1) явный OPENCODE_CONFIG из Server
+// или окружения процесса, (2) OPENCODE_CONFIG_DIR / глобальный каталог
+// ~/.config/opencode. Возвращает "" если ничего не найдено.
+func opencodeConfigPath(cfgFile, cfgDir string) string {
+	// (1) явный файл конфига — Server.Config или env OPENCODE_CONFIG.
+	p := cfgFile
+	if p == "" {
+		p = os.Getenv("OPENCODE_CONFIG")
+	}
+	if p != "" {
+		if st, err := os.Stat(p); err == nil && !st.IsDir() {
+			return p
+		}
+	}
+	// (2) каталог конфигов.
+	dir := cfgDir
+	if dir == "" {
+		dir = os.Getenv("OPENCODE_CONFIG_DIR")
+	}
+	if dir == "" {
+		home, err := os.UserHomeDir()
+		if err != nil || home == "" {
+			return ""
+		}
+		dir = filepath.Join(home, ".config", "opencode")
+		if x := os.Getenv("XDG_CONFIG_HOME"); x != "" {
+			dir = filepath.Join(x, "opencode")
+		}
+	}
+	for _, name := range []string{"opencode.json", "opencode.jsonc"} {
+		cand := filepath.Join(dir, name)
+		if st, err := os.Stat(cand); err == nil && !st.IsDir() {
+			return cand
+		}
+	}
+	return ""
+}
+
+// ReadModelRef извлекает top-level "model" из конфига opencode и возвращает
+// его как ModelRef. Модель не задана — вернёт (nil, nil); ошибка чтения/парсинга
+// возвращается (вызывающий логирует warning и продолжает без хардпина).
+func ReadModelRef(cfgFile, cfgDir string) (*ModelRef, error) {
+	path := opencodeConfigPath(cfgFile, cfgDir)
+	if path == "" {
+		return nil, nil
+	}
+	b, err := os.ReadFile(path)
+	if err != nil {
+		return nil, fmt.Errorf("config: читать %s: %w", path, err)
+	}
+	doc := struct {
+		Model json.RawMessage `json:"model"`
+	}{}
+	if err := json.Unmarshal(stripJSONC(b), &doc); err != nil {
+		return nil, fmt.Errorf("config: парсить %s: %w", path, err)
+	}
+	if len(doc.Model) == 0 || strings.TrimSpace(string(doc.Model)) == "null" {
+		return nil, nil
+	}
+	// "model" может быть строкой "provider/id" или объектом {providerID, id}.
+	var s string
+	if err := json.Unmarshal(doc.Model, &s); err == nil {
+		ref := parseModelString(s)
+		if ref == nil {
+			return nil, fmt.Errorf("config: некорректная model %q в %s (ожидается provider/id)", s, path)
+		}
+		return ref, nil
+	}
+	var ref ModelRef
+	if err := json.Unmarshal(doc.Model, &ref); err != nil {
+		return nil, fmt.Errorf("config: некорректная model в %s", path)
+	}
+	if ref.ProviderID == "" || ref.ID == "" {
+		return nil, fmt.Errorf("config: model без providerID/id в %s", path)
+	}
+	return &ref, nil
+}
+
+// parseModelString разбирает "provider/id" (как ModelV2.parse: провайдер — всё
+// до первого '/', id — остаток). Возвращает nil при пустой/некорректной строке.
+func parseModelString(s string) *ModelRef {
+	s = strings.TrimSpace(s)
+	if s == "" {
+		return nil
+	}
+	i := strings.IndexByte(s, '/')
+	if i <= 0 || i == len(s)-1 {
+		return nil
+	}
+	return &ModelRef{ProviderID: s[:i], ID: s[i+1:]}
+}
+
+// stripJSONC удаляет // и /* */ комментарии (вне строк), сохраняя позиции
+// переводов строк, чтобы json.Unmarshal не споткнулся о trailing-комма.
+func stripJSONC(b []byte) []byte {
+	out := make([]byte, 0, len(b))
+	inStr := false
+	esc := false
+	i := 0
+	for i < len(b) {
+		c := b[i]
+		if inStr {
+			out = append(out, c)
+			if esc {
+				esc = false
+			} else if c == '\\' {
+				esc = true
+			} else if c == '"' {
+				inStr = false
+			}
+			i++
+			continue
+		}
+		switch {
+		case c == '"':
+			inStr = true
+			out = append(out, c)
+			i++
+		case c == '/' && i+1 < len(b) && b[i+1] == '/':
+			for i < len(b) && b[i] != '\n' {
+				i++
+			}
+			if i < len(b) {
+				out = append(out, '\n')
+				i++
+			}
+		case c == '/' && i+1 < len(b) && b[i+1] == '*':
+			i += 2
+			for i+1 < len(b) && !(b[i] == '*' && b[i+1] == '/') {
+				i++
+			}
+			i += 2
+		default:
+			out = append(out, c)
+			i++
+		}
+	}
+	return dropTrailingCommas(out)
+}
+
+// dropTrailingCommas убирает запятые перед '}' / ']' (допускаются в JSONC).
+func dropTrailingCommas(b []byte) []byte {
+	out := make([]byte, 0, len(b))
+	for i := 0; i < len(b); i++ {
+		if b[i] == ',' {
+			j := i + 1
+			for j < len(b) && (b[j] == ' ' || b[j] == '\t' || b[j] == '\n' || b[j] == '\r') {
+				j++
+			}
+			if j < len(b) && (b[j] == '}' || b[j] == ']') {
+				continue
+			}
+		}
+		out = append(out, b[i])
+	}
+	return out
+}
--- a/internal/opencode/config_test.go
+++ b/internal/opencode/config_test.go
@@ -0,0 +1,85 @@
+package opencode
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestReadModelRef_String(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "opencode.jsonc")
+	// конфиг с комментариями и trailing-запятыми (JSONC).
+	src := `{
+		// комментарий
+		"model": "tokentool/deepseek/deepseek-v4-flash-0731", /* и блочный */
+		"provider": {
+			"tokentool": {"api": {"type": "aisdk", "package": "@ai-sdk/openai-compatible", "url": "https://x"}},
+		},
+	}`
+	if err := os.WriteFile(path, []byte(src), 0o644); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+	m, err := ReadModelRef(path, "")
+	if err != nil {
+		t.Fatalf("ReadModelRef err: %v", err)
+	}
+	if m == nil || m.ProviderID != "tokentool" || m.ID != "deepseek/deepseek-v4-flash-0731" {
+		t.Errorf("model = %+v, want tokentool/deepseek-v4-flash-0731", m)
+	}
+}
+
+func TestReadModelRef_Object(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "opencode.json")
+	src := `{"model": {"providerID": "tokentool", "id": "deepseek/deepseek-v4-flash-0731"}}`
+	if err := os.WriteFile(path, []byte(src), 0o644); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+	m, err := ReadModelRef(path, "")
+	if err != nil {
+		t.Fatalf("ReadModelRef err: %v", err)
+	}
+	if m == nil || m.ID != "deepseek/deepseek-v4-flash-0731" {
+		t.Errorf("model = %+v, want object-форма", m)
+	}
+}
+
+func TestReadModelRef_Missing(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "opencode.json")
+	src := `{"provider": {}}`
+	if err := os.WriteFile(path, []byte(src), 0o644); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+	m, err := ReadModelRef(path, "")
+	if err != nil {
+		t.Fatalf("ReadModelRef err: %v", err)
+	}
+	if m != nil {
+		t.Errorf("model = %+v, want nil (model не задан)", m)
+	}
+}
+
+func TestReadModelRef_NoFile(t *testing.T) {
+	dir := t.TempDir()
+	m, err := ReadModelRef(filepath.Join(dir, "nope.json"), dir)
+	if err != nil {
+		t.Fatalf("ReadModelRef err: %v", err)
+	}
+	if m != nil {
+		t.Errorf("model = %+v, want nil", m)
+	}
+}
+
+func TestReadModelRef_Bad(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "opencode.json")
+	src := `{"model": 12345}`
+	if err := os.WriteFile(path, []byte(src), 0o644); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+	if _, err := ReadModelRef(path, ""); err == nil {
+		t.Error("ReadModelRef должен упасть на некорректной model")
+	}
+}
--- a/internal/opencode/pool.go
+++ b/internal/opencode/pool.go
@@ -19,6 +19,8 @@ import (
 // директории → каждая сессия API привязана к правильному project-каталогу.
 type Pool struct {
 	Bin       string
+	Config    string
+	ConfigDir string
 	DBPath    string
 	Host      string
 	BasePort  int
@@ -71,6 +73,8 @@ func (p *Pool) EnsureRoot(ctx context.Context) error {
 	}
 	s := &Server{
 		Bin:       p.Bin,
+		Config:    p.Config,
+		ConfigDir: p.ConfigDir,
 		DBPath:    p.DBPath,
 		Host:      p.Host,
 		Password:  p.Password,
@@ -99,6 +103,8 @@ func (p *Pool) Ensure(ctx context.Context, dir string) (*Server, error) {
 	abs := filepath.Clean(dir)
 	s := &Server{
 		Bin:       p.Bin,
+		Config:    p.Config,
+		ConfigDir: p.ConfigDir,
 		DBPath:    p.DBPath,
 		Host:      p.Host,
 		Password:  p.Password,
--- a/internal/opencode/runner.go
+++ b/internal/opencode/runner.go
@@ -73,45 +73,31 @@ func (r *Runner) Run(ctx context.Context, prompt, cwd, agent, sessionID string)
 	if err != nil {
 		return nil, err
 	}
-	c := &Client{BaseURL: srv.Addr(), Password: srv.Password, Directory: srv.Dir, Debug: r.Debug}
+	c := &Client{BaseURL: srv.Addr(), Password: srv.Password, Debug: r.Debug}

-	// Сессия: заданная (resume) или новая. Модель НЕ выбираем — opencode сам
-	// берёт её по умолчанию из своего глобального конфига.
+	// Модель по умолчанию из конфига opencode — хардпиним её в сессии, чтобы
+	// не зависеть от fallback-логики opencode (класс O5 WARN: если модель не
+	// считывается/не задана — предупреждаем и работаем без явного указания).
+	model, mErr := ReadModelRef(srv.Config, srv.ConfigDir)
+	if mErr != nil {
+		r.logf("WARN opencode: не удалось прочитать model из конфига: %v", mErr)
+	} else if model == nil {
+		r.logf("WARN opencode: в конфиге opencode не задан top-level model — модель не хардпинится (риск fallback)")
+	} else {
+		r.logf("opencode(%s) model=%s", agent, model)
+	}
+
+	// Сессия: заданная (resume) или новая.
 	sid := sessionID
 	if sid == "" {
-		sid, err = c.CreateSession(ctx, agent)
+		sid, err = c.CreateSession(ctx, model)
 		if err != nil {
 			return nil, fmt.Errorf("opencode: create session: %w", err)
 		}
 		r.logf("opencode(%s) session=%s на %s", agent, sid, srv.Addr())
-		r.logf("opencode(%s) сообщения сессии: %s", agent, SessionMessagesURL(srv.Addr(), sid))
 	}

-	return r.awaitVerdict(ctx, c, sid, agent, prompt)
-}
-
-// SessionMessages возвращает транскрипт сессии (шаги агента: сообщения,
-// тексты, tool-вызовы) в хронологическом порядке для постмортем-анализа.
-// sessionID пустой → пустая строка без ошибки. Ошибки чтения возвращаются
-// как есть — вызывающий (постмортем) решает, логировать и продолжить.
-func (r *Runner) SessionMessages(ctx context.Context, cwd, sessionID string) (string, error) {
-	r.defaults()
-	if r.Pool == nil {
-		return "", fmt.Errorf("opencode: Pool не задан (API-режим обязателен)")
-	}
-	if sessionID == "" {
-		return "", nil
-	}
-	srv, err := r.Pool.Ensure(ctx, cwd)
-	if err != nil {
-		return "", err
-	}
-	c := &Client{BaseURL: srv.Addr(), Password: srv.Password, Directory: srv.Dir, Debug: r.Debug}
-	msgs, err := c.Messages(ctx, sessionID)
-	if err != nil {
-		return "", err
-	}
-	return renderTranscript(msgs), nil
+	return r.awaitVerdict(ctx, c, model, sid, agent, prompt)
 }

 // settlePolls — сколько подряд опросов должно подтвердить завершение ответа,
@@ -123,7 +109,7 @@ const settlePolls = 2
 // контролируя idle/hard таймауты. Завершение: сессия ушла из активных дренажей
 // И есть новое завершённое assistant-сообщение, стабильное в течение settlePolls
 // опросов. Возвращает вердикт (текст text-партов), либо rc=-1 при таймауте.
-func (r *Runner) awaitVerdict(ctx context.Context, c *Client, sid, agent, prompt string) (*Result, error) {
+func (r *Runner) awaitVerdict(ctx context.Context, c *Client, model *ModelRef, sid, agent, prompt string) (*Result, error) {
 	// admit промпта; граница «новых» сообщений — время создания user-сообщения.
 	admittedAt := time.Now().UnixMilli()
 	adm, err := c.Prompt(ctx, sid, prompt)
@@ -201,7 +187,7 @@ func (r *Runner) awaitVerdict(ctx context.Context, c *Client, sid, agent, prompt
 			doneSeen++
 			emptySeen = 0
 			if doneSeen >= settlePolls {
-				return r.verdict(cur, msgs, admittedAt, sid)
+				return r.verdict(model, cur, msgs, admittedAt, sid)
 			}
 		case !active && cur == nil:
 			// сессия завершилась, но нового assistant-сообщения так и нет
@@ -221,17 +207,19 @@ func (r *Runner) awaitVerdict(ctx context.Context, c *Client, sid, agent, prompt
 }

 // verdict собирает финальный результат из новых assistant-сообщений.
-func (r *Runner) verdict(cur *v2Message, msgs []v2Message, since int64, sid string) (*Result, error) {
+// Проверяет фактическую модель ответа и логирует warning при расхождении
+// с ожидаемой (устойчивость к «не той» модели — класс O5 WARN).
+func (r *Runner) verdict(model *ModelRef, cur *v2Message, msgs []v2Message, since int64, sid string) (*Result, error) {
+	if model != nil && cur.Model != nil && (model.ProviderID != cur.Model.ProviderID || model.ID != cur.Model.ID) {
+		r.logf("WARN opencode: сессия %s отвечала моделью %s, а не ожидаемой %s — проверь providers в конфиге (v2-схема: provider.api / request, а не npm/options)", sid, cur.Model, model)
+	}
 	if cur.Error != nil && cur.Error.Message != "" {
 		return nil, &ClientErr{Op: "prompt", Err: errors.New(cur.Error.Message)}
 	}
-	texts, usedReasoning := assistantVerdict(msgs, since)
+	texts := assistantText(msgs, since)
 	if len(texts) == 0 {
 		return nil, &ClientErr{Op: "prompt", Err: errors.New("нет text-части в ответе")}
 	}
-	if usedReasoning {
-		r.logf("WARN opencode: в ответе нет text-части — использую reasoning-парты как вердикт")
-	}
 	vd := stripFence(strings.Join(texts, "\n"))
 	r.logf("opencode вердикт готов (%d байт)", len(vd))
 	return &Result{RC: 0, Stdout: vd, SessionID: sid}, nil
--- a/internal/opencode/runner_test.go
+++ b/internal/opencode/runner_test.go
@@ -10,6 +10,8 @@ import (

 // fakePool создаёт Pool, в котором уже «живёт» сервер для каталога (без spawn):
 // Server{URL: fake.URL}, поэтому Runner ходит по HTTP на фейк-API.
+// XDG_CONFIG_HOME уводится во временный каталог, чтобы ReadModelRef не читал
+// реальный пользовательский конфиг opencode (детерминизм тестов).
 func fakePool(t *testing.T, f *fakeAPIServer, dir string) (*Pool, *Client) {
 	t.Helper()
 	ts := httptestURL(t, f)
@@ -108,28 +110,6 @@ func TestRun_ReasoningGrowth(t *testing.T) {
 	}
 }

-func TestRun_ReasoningOnlyVerdict(t *testing.T) {
-	t.Setenv("XDG_CONFIG_HOME", t.TempDir())
-	dir := t.TempDir()
-	// завершённый ответ без text-парта, только reasoning — вердикт собирается
-	// из reasoning (fallback) вместо ошибки «нет text-части в ответе».
-	f := &fakeAPIServer{verdictReasoning: "размышления без текста"}
-	p, _ := fakePool(t, f, dir)
-
-	r := &Runner{Pool: p, IdleTimeout: time.Minute, HardTimeout: time.Minute,
-		PollInterval: 5 * time.Millisecond, Stdout: io.Discard}
-	res, err := r.Run(context.Background(), "task", dir, "dev", "")
-	if err != nil {
-		t.Fatalf("Run err: %v", err)
-	}
-	if res.RC != 0 {
-		t.Errorf("RC = %d, want 0 (reasoning-only вердикт)", res.RC)
-	}
-	if !contains(res.Stdout, "размышления без текста") {
-		t.Errorf("Stdout = %q, want reasoning fallback", res.Stdout)
-	}
-}
-
 func TestRun_ContextCancel(t *testing.T) {
 	t.Setenv("XDG_CONFIG_HOME", t.TempDir())
 	dir := t.TempDir()
@@ -146,7 +126,7 @@ func TestRun_ContextCancel(t *testing.T) {
 		done <- res
 		errCh <- err
 	}()
-	time.Sleep(6000 * time.Millisecond)
+	time.Sleep(30 * time.Millisecond)
 	cancel()
 	res := <-done
 	if err := <-errCh; err != nil {
--- a/internal/opencode/server.go
+++ b/internal/opencode/server.go
@@ -8,7 +8,6 @@ import (
 	"net/http"
 	"os"
 	"os/exec"
-	"path/filepath"
 	"sync"
 	"time"
 )
@@ -25,6 +24,8 @@ import (
 //     отдаёт URL, процессом не владеет.
 type Server struct {
 	Bin       string // путь к opencode (по умолчанию "opencode")
+	Config    string // OPENCODE_CONFIG
+	ConfigDir string // OPENCODE_CONFIG_DIR
 	DBPath    string // рабочая БД сервера (передам env, если задана)

 	Host     string // hostname для прослушивания
@@ -32,12 +33,6 @@ type Server struct {
 	Password string // basic auth (если непустой — сервер защищён)
 	Dir      string // каталог, в котором запускается serve (project сервера)

-	// ConfigPath — путь к глобальному конфигу opencode (opencode.jsonc).
-	// Передаётся serve через env OPENCODE_CONFIG, чтобы гарантированно
-	// подхватить модель/провайдеров независимо от резолва глобального пути.
-	// Пусто — serve резолвит конфиг сам (см. defaults).
-	ConfigPath string
-
 	// URL задаёт внешний сервер. Пусто — супервайзер владеет процессом.
 	URL         string
 	PollInterval time.Duration // как часто проверять /global/health
@@ -67,20 +62,6 @@ func (s *Server) defaults() {
 	if s.Stdout == nil {
 		s.Stdout = os.Stderr
 	}
-	if s.ConfigPath == "" {
-		s.ConfigPath = defaultOpenCodeConfigPath()
-	}
-}
-
-// defaultOpenCodeConfigPath возвращает путь к глобальному конфигу opencode,
-// совпадающий с тем, что opencode загружает по умолчанию: ~/.config/opencode/
-// (в т.ч. на Windows — см. Global.Path.config в исходниках opencode).
-func defaultOpenCodeConfigPath() string {
-	home, _ := os.UserHomeDir()
-	if home == "" {
-		home = "."
-	}
-	return filepath.Join(home, ".config", "opencode", "opencode.jsonc")
 }

 // baseURL собирает полный адрес сервера (http://host:port).
@@ -120,8 +101,6 @@ func (s *Server) Start(ctx context.Context) error {
 	s.done = done
 	s.mu.Unlock()

-	log.Printf("opencode serve: spawn dir=%s HOME=%q USERPROFILE=%q OPENCODE_CONFIG=%q (serve наследует окружение родителя)", cmd.Dir, os.Getenv("HOME"), os.Getenv("USERPROFILE"), s.ConfigPath)
-
 	if err := cmd.Start(); err != nil {
 		return fmt.Errorf("opencode serve: start %v: %w", s.Bin, err)
 	}
@@ -145,8 +124,22 @@ func (s *Server) serveCmd(ctx context.Context) *exec.Cmd {
 	// Своя process-group: чтобы killGroup (по pgid) убивал только сервер и его
 	// дочерние процессы, а не чужой процесс (например, тест-реннер).
 	setpgid(cmd)
-	// Env не задаём: serve наследует окружение родителя и сам резолвит свой
-	// глобальный/локальный конфиг (модель/провайдеры, агентов, БД) как обычно.
+	env := append(os.Environ(),
+		"OPENCODE_DISABLE_AUTOUPDATE=1",
+		"OPENCODE_DISABLE_MODELS_FETCH=1")
+	if s.Config != "" {
+		env = append(env, "OPENCODE_CONFIG="+s.Config)
+	}
+	if s.ConfigDir != "" {
+		env = append(env, "OPENCODE_CONFIG_DIR="+s.ConfigDir)
+	}
+	if s.DBPath != "" {
+		env = append(env, "OPENCODE_DB="+s.DBPath)
+	}
+	if s.Password != "" {
+		env = append(env, "OPENCODE_SERVER_PASSWORD="+s.Password)
+	}
+	cmd.Env = env
 	return cmd
 }

--- a/internal/opencode/server_test.go
+++ b/internal/opencode/server_test.go
@@ -199,27 +199,3 @@ func atoiOrZero(s string) int {
 	}
 	return n
 }
-
-func TestServeCmd_NoCustomEnv(t *testing.T) {
-	// serveCmd не должен задавать свой Env: serve наследует окружение родителя
-	// и сам резолвит конфиг/БД/пароль как обычно.
-	s := &Server{}
-	s.defaults()
-	cmd := s.serveCmd(context.Background())
-	if cmd.Env != nil {
-		for _, kv := range cmd.Env {
-			if strings.HasPrefix(kv, "OPENCODE_") {
-				t.Errorf("serveCmd: не ожидал env %q", kv)
-			}
-		}
-	}
-}
-
-func TestServerCmd_CustomOpenCodeConfig(t *testing.T) {
-	// явно заданный путь переопределяет дефолтный
-	s := &Server{ConfigPath: `C:\custom\opencode.jsonc`}
-	s.defaults()
-	if s.ConfigPath != `C:\custom\opencode.jsonc` {
-		t.Errorf("ConfigPath = %q, want explicit", s.ConfigPath)
-	}
-}
--- a/internal/storage/models.go
+++ b/internal/storage/models.go
@@ -40,12 +40,6 @@ func IsTerminal(s Status) bool {
 	return model.IsTerminal(s)
 }

-// Step — этап задачи с собственным критерием готовности.
-type Step struct {
-	Title string `json:"title"`
-	AC    string `json:"ac"` // acceptance criterion этапа
-}
-
 // Task — запись задачи в БД.
 type Task struct {
 	ID        int64      `json:"id"`
@@ -56,7 +50,6 @@ type Task struct {
 	Repos     []string   `json:"repos"`      // список репозиториев (основной)
 	Why       string     `json:"why"`
 	AC        string     `json:"ac"`         // acceptance criteria
-	Steps     []Step     `json:"steps"`    // этапы задачи (опционально)
 	TaskTag   string     `json:"task_tag"`   // UUID, стабильный на всю жизнь
 	Status    Status     `json:"status"`
 	CreatedAt SQLiteTime `json:"created_at"`
@@ -95,25 +88,6 @@ func (t *Task) SetReposFromDB(repos string) {
 	_ = json.Unmarshal([]byte(repos), &t.Repos)
 }

-// StepsJoined возвращает steps как одну строку (JSON-массив) для хранения в БД.
-// Пустой список → пустая строка.
-func (t *Task) StepsJoined() string {
-	if len(t.Steps) == 0 {
-		return ""
-	}
-	b, _ := json.Marshal(t.Steps)
-	return string(b)
-}
-
-// SetStepsFromDB заполняет Steps из сохранённой строки (JSON).
-func (t *Task) SetStepsFromDB(steps string) {
-	if steps == "" {
-		t.Steps = nil
-		return
-	}
-	_ = json.Unmarshal([]byte(steps), &t.Steps)
-}
-
 // TraceStatus — алиас доменного статуса трассировки.
 type TraceStatus = model.TraceStatus

--- a/internal/storage/storage.go
+++ b/internal/storage/storage.go
@@ -173,13 +173,6 @@ func (s *Storage) migrate(ctx context.Context) error {
 			return fmt.Errorf("%w: migrate add repos: %w", ErrDB, err)
 		}
 	}
-	// Доп. колонка steps (этапы задачи). Idempotent.
-	if _, err := s.db.ExecContext(ctx,
-		`ALTER TABLE tasks ADD COLUMN steps TEXT NOT NULL DEFAULT ''`); err != nil {
-		if !isDuplicateColumn(err) {
-			return fmt.Errorf("%w: migrate add steps: %w", ErrDB, err)
-		}
-	}
 	return nil
 }

--- a/internal/storage/storage_test.go
+++ b/internal/storage/storage_test.go
@@ -150,44 +150,6 @@ func TestUpdateTaskNotFound(t *testing.T) {
 	}
 }

-func TestCreateAndGetTask_Steps(t *testing.T) {
-	s, ctx := setupTestDB(t)
-	task := &Task{
-		ChatID:  "tg://steps",
-		Title:   "Steps task",
-		TaskTag: "steps-1",
-		Steps: []Step{
-			{Title: "Реализовать модель", AC: "структура готова"},
-			{Title: "Добавить API", AC: "эндпоинт отвечает"},
-		},
-	}
-	id, err := s.CreateTask(ctx, task)
-	if err != nil {
-		t.Fatalf("CreateTask: %v", err)
-	}
-
-	got, err := s.GetTask(ctx, id)
-	if err != nil {
-		t.Fatalf("GetTask: %v", err)
-	}
-	if len(got.Steps) != 2 {
-		t.Fatalf("steps len = %d, want 2", len(got.Steps))
-	}
-	if got.Steps[0].Title != "Реализовать модель" || got.Steps[0].AC != "структура готова" {
-		t.Fatalf("steps[0] = %q / %q, want модель / структура готова", got.Steps[0].Title, got.Steps[0].AC)
-	}
-
-	// апдейт этапов
-	got.Steps = append(got.Steps, Step{Title: "Ревью", AC: "пройден review"})
-	if err := s.UpdateTask(ctx, got); err != nil {
-		t.Fatalf("UpdateTask steps: %v", err)
-	}
-	got2, _ := s.GetTask(ctx, id)
-	if len(got2.Steps) != 3 {
-		t.Fatalf("steps len after update = %d, want 3", len(got2.Steps))
-	}
-}
-
 func TestListTasks(t *testing.T) {
 	s, ctx := setupTestDB(t)
 	for i := 0; i < 5; i++ {
@@ -302,26 +264,6 @@ func TestUpdateTraceOutput(t *testing.T) {
 	}
 }

-// TestDeleteTracesByAgent — удаление трасс по агенту (сброс маркера при /retry).
-func TestDeleteTracesByAgent(t *testing.T) {
-	s, ctx := setupTestDB(t)
-	task := &Task{ChatID: "tg://del", TaskTag: "delete-by-agent"}
-	id, _ := s.CreateTask(ctx, task)
-
-	_, _ = s.AppendTrace(ctx, &Trace{TaskID: id, Agent: "dev"})
-	_, _ = s.AppendTrace(ctx, &Trace{TaskID: id, Agent: "postmortem"})
-	_, _ = s.AppendTrace(ctx, &Trace{TaskID: id, Agent: "postmortem"})
-
-	if err := s.DeleteTracesByAgent(ctx, id, "postmortem"); err != nil {
-		t.Fatalf("DeleteTracesByAgent: %v", err)
-	}
-
-	traces, _ := s.GetTraces(ctx, id)
-	if len(traces) != 1 || traces[0].Agent != "dev" {
-		t.Fatalf("traces = %d (agent %q), want только dev", len(traces), traces[0].Agent)
-	}
-}
-
 // хелперы для проверки классов ошибок
 func IsNotFound(err error) bool {
 	return errors.Is(err, ErrNotFound)
--- a/internal/storage/tasks.go
+++ b/internal/storage/tasks.go
@@ -30,10 +30,10 @@ func (s *Storage) CreateTask(ctx context.Context, t *Task) (int64, error) {
 	}
 	now := Now()
 	res, err := s.db.ExecContext(ctx, `
-		INSERT INTO tasks (chat_id, title, goal, repo, repos, why, ac, steps, task_tag, status, created_at, updated_at)
-		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+		INSERT INTO tasks (chat_id, title, goal, repo, repos, why, ac, task_tag, status, created_at, updated_at)
+		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
 		t.ChatID, t.Title, t.Goal, t.Repo, t.ReposJoined(), t.Why, t.AC,
-		t.StepsJoined(), t.TaskTag, StatusDraft, now, now,
+		t.TaskTag, StatusDraft, now, now,
 	)
 	if err != nil {
 		return 0, fmt.Errorf("%w: create task: %w", ErrDB, err)
@@ -53,12 +53,11 @@ func (s *Storage) CreateTask(ctx context.Context, t *Task) (int64, error) {
 func (s *Storage) GetTask(ctx context.Context, id int64) (*Task, error) {
 	t := &Task{}
 	var reposStr string
-	var stepsStr string
 	err := s.db.QueryRowContext(ctx, `
-		SELECT id, chat_id, title, goal, repo, repos, why, ac, steps, task_tag, status, created_at, updated_at
+		SELECT id, chat_id, title, goal, repo, repos, why, ac, task_tag, status, created_at, updated_at
 		FROM tasks WHERE id = ?`, id).Scan(
 		&t.ID, &t.ChatID, &t.Title, &t.Goal, &t.Repo, &reposStr,
-		&t.Why, &t.AC, &stepsStr, &t.TaskTag, &t.Status, &t.CreatedAt, &t.UpdatedAt,
+		&t.Why, &t.AC, &t.TaskTag, &t.Status, &t.CreatedAt, &t.UpdatedAt,
 	)
 	if err == sql.ErrNoRows {
 		return nil, fmt.Errorf("%w: task %d", ErrNotFound, id)
@@ -67,7 +66,6 @@ func (s *Storage) GetTask(ctx context.Context, id int64) (*Task, error) {
 		return nil, fmt.Errorf("%w: get task %d: %w", ErrDB, id, err)
 	}
 	t.SetReposFromDB(reposStr)
-	t.SetStepsFromDB(stepsStr)
 	return t, nil
 }

@@ -96,9 +94,9 @@ func (s *Storage) UpdateTask(ctx context.Context, t *Task) error {
 	now := Now()
 	res, err := s.db.ExecContext(ctx, `
 		UPDATE tasks
-		SET title=?, goal=?, repo=?, repos=?, why=?, ac=?, steps=?, status=?, updated_at=?
+		SET title=?, goal=?, repo=?, repos=?, why=?, ac=?, status=?, updated_at=?
 		WHERE id=?`,
-		t.Title, t.Goal, t.Repo, t.ReposJoined(), t.Why, t.AC, t.StepsJoined(), t.Status, now, t.ID,
+		t.Title, t.Goal, t.Repo, t.ReposJoined(), t.Why, t.AC, t.Status, now, t.ID,
 	)
 	if err != nil {
 		return fmt.Errorf("%w: update task %d: %w", ErrDB, t.ID, err)
@@ -116,14 +114,13 @@ func (s *Storage) UpdateTask(ctx context.Context, t *Task) error {
 func (s *Storage) GetActiveTaskByChatID(ctx context.Context, chatID string) (*Task, error) {
 	t := &Task{}
 	var reposStr string
-	var stepsStr string
 	err := s.db.QueryRowContext(ctx, `
-		SELECT id, chat_id, title, goal, repo, repos, why, ac, steps, task_tag, status, created_at, updated_at
+		SELECT id, chat_id, title, goal, repo, repos, why, ac, task_tag, status, created_at, updated_at
 		FROM tasks
 		WHERE chat_id = ? AND status NOT IN ('success','cancelled','aborted','closed')
 		ORDER BY updated_at DESC LIMIT 1`, chatID).Scan(
 		&t.ID, &t.ChatID, &t.Title, &t.Goal, &t.Repo, &reposStr,
-		&t.Why, &t.AC, &stepsStr, &t.TaskTag, &t.Status, &t.CreatedAt, &t.UpdatedAt)
+		&t.Why, &t.AC, &t.TaskTag, &t.Status, &t.CreatedAt, &t.UpdatedAt)
 	if err == sql.ErrNoRows {
 		return nil, fmt.Errorf("%w: no active task for chat %s", ErrNotFound, chatID)
 	}
@@ -131,7 +128,6 @@ func (s *Storage) GetActiveTaskByChatID(ctx context.Context, chatID string) (*Ta
 		return nil, fmt.Errorf("%w: get active task %s: %w", ErrDB, chatID, err)
 	}
 	t.SetReposFromDB(reposStr)
-	t.SetStepsFromDB(stepsStr)
 	return t, nil
 }

@@ -153,7 +149,7 @@ func (s *Storage) ListTasks(ctx context.Context, filter TaskFilter) ([]*Task, er
 	args = append(args, filter.Limit, filter.Offset)

 	rows, err := s.db.QueryContext(ctx, `
-		SELECT id, chat_id, title, goal, repo, repos, why, ac, steps, task_tag, status, created_at, updated_at
+		SELECT id, chat_id, title, goal, repo, repos, why, ac, task_tag, status, created_at, updated_at
 		FROM tasks WHERE `+where+` ORDER BY updated_at DESC LIMIT ? OFFSET ?`, args...)
 	if err != nil {
 		return nil, fmt.Errorf("%w: list tasks: %w", ErrDB, err)
@@ -164,13 +160,11 @@ func (s *Storage) ListTasks(ctx context.Context, filter TaskFilter) ([]*Task, er
 	for rows.Next() {
 		t := &Task{}
 		var reposStr string
-		var stepsStr string
 		if err := rows.Scan(&t.ID, &t.ChatID, &t.Title, &t.Goal, &t.Repo, &reposStr,
-			&t.Why, &t.AC, &stepsStr, &t.TaskTag, &t.Status, &t.CreatedAt, &t.UpdatedAt); err != nil {
+			&t.Why, &t.AC, &t.TaskTag, &t.Status, &t.CreatedAt, &t.UpdatedAt); err != nil {
 			return nil, fmt.Errorf("%w: scan task: %w", ErrDB, err)
 		}
 		t.SetReposFromDB(reposStr)
-		t.SetStepsFromDB(stepsStr)
 		tasks = append(tasks, t)
 	}
 	return tasks, rows.Err()
--- a/internal/storage/traces.go
+++ b/internal/storage/traces.go
@@ -107,17 +107,6 @@ func (s *Storage) GetLatestTrace(ctx context.Context, taskID int64, agent string
 	return tr, nil
 }

-// DeleteTracesByAgent удаляет все трассы задачи с заданным агентом
-// (сброс маркера при /retry N: чистый перезапуск без наследия анализа).
-func (s *Storage) DeleteTracesByAgent(ctx context.Context, taskID int64, agent string) error {
-	_, err := s.db.ExecContext(ctx,
-		`DELETE FROM traces WHERE task_id=? AND agent=?`, taskID, agent)
-	if err != nil {
-		return fmt.Errorf("%w: delete traces agent %s for task %d: %w", ErrDB, agent, taskID, err)
-	}
-	return nil
-}
-
 // DeleteTrace удаляет трассу. Только для тестов/админки.
 func (s *Storage) DeleteTrace(ctx context.Context, id int64) error {
 	res, err := s.db.ExecContext(ctx, `DELETE FROM traces WHERE id = ?`, id)
--- a/internal/ui/chat_panel.go
+++ b/internal/ui/chat_panel.go
@@ -1,44 +0,0 @@
-package ui
-
-// ChatPanel — панель «Диалог» (спец 12.12): транскрипт диалога выбранной
-// задачи + композитор (поле ввода и кнопки команд).
-//
-// Транскрипт — буфер ограниченного размера; при превышении лимита старые
-// строки отбрасываются. Композитор подключается к ui.Commands через
-// SetCommands. Обновление — на потоке Fyne; вызывающий уже внутри fyne.Do.
-type ChatPanel interface {
-	// SetTranscript заменяет содержимое диалога полным рендером.
-	SetTranscript(text string)
-	// Append добавляет строку в диалог (буфер ограничен).
-	Append(text string)
-	// Clear очищает диалог (задача недоступна/не выбрана).
-	Clear()
-	// SetCommands подключает команды к композитору (ввод + кнопки).
-	SetCommands(c *Commands)
-	// SetBoundTask сообщает панели задачу, к которой привязана вкладка
-	// (0 — свободный чат). Кнопка «Перезапустить» (/retry N) активна только
-	// для вкладки с привязанной задачей.
-	SetBoundTask(taskID int64)
-}
-
-// NilChatPanel — no-op реализация ChatPanel для headless-режима и тестов.
-type NilChatPanel struct{}
-
-// NewNilChatPanel создаёт NilChatPanel.
-func NewNilChatPanel() *NilChatPanel { return &NilChatPanel{} }
-
-func (NilChatPanel) SetTranscript(string) {}
-func (NilChatPanel) Append(string)        {}
-func (NilChatPanel) Clear()               {}
-func (NilChatPanel) SetCommands(*Commands) {}
-func (NilChatPanel) SetBoundTask(int64)   {}
-
-// FormatRole — строка роли в диалоге (pure-функция, спец 12.12).
-func FormatRole(role string) string {
-	switch role {
-	case "user":
-		return "👤 "
-	default:
-		return "🤖 "
-	}
-}
--- a/internal/ui/chat_panel_test.go
+++ b/internal/ui/chat_panel_test.go
@@ -1,54 +0,0 @@
-package ui
-
-import "testing"
-
-// FormatRole — строка роли в диалоге (спец 12.12), pure-функция без Fyne.
-func TestFormatRole(t *testing.T) {
-	if FormatRole("user") != "👤 " {
-		t.Errorf("user: got %q, want «👤 »", FormatRole("user"))
-	}
-	if FormatRole("assistant") != "🤖 " {
-		t.Errorf("assistant: got %q, want «🤖 »", FormatRole("assistant"))
-	}
-	if FormatRole("") != "🤖 " {
-		t.Errorf("default: got %q, want «🤖 »", FormatRole(""))
-	}
-}
-
-// NilChatPanel — no-op контракт (спец 12.8): безопасно для headless/тестов.
-func TestNilChatPanelNoop(t *testing.T) {
-	p := NewNilChatPanel()
-	c := NewCommands(nil)
-	p.SetTranscript("история")
-	p.Append("строка")
-	p.Clear()
-	p.SetCommands(c)
-	p.SetBoundTask(7)
-}
-
-// Кнопка «Перезапустить» — полный аналог Telegram-команды /retry N:
-// в канал уходит ровно тот же текст, что при ручном вводе команды.
-func TestRetryButtonSubmitsSameCommandAsTelegram(t *testing.T) {
-	var got []string
-	c := NewCommands(func(text string) { got = append(got, text) })
-
-	c.Retry(42)
-
-	if len(got) != 1 || got[0] != "/retry 42" {
-		t.Fatalf("got %v, want [/retry 42]", got)
-	}
-}
-
-// Свободная вкладка (без задачи): Retry(id<=0) — no-op, ничего не отправляется
-// (кнопка «Перезапустить» на такой вкладке неактивна).
-func TestRetryWithoutTaskIsNoop(t *testing.T) {
-	var got []string
-	c := NewCommands(func(text string) { got = append(got, text) })
-
-	c.Retry(0)
-	c.Retry(-5)
-
-	if len(got) != 0 {
-		t.Fatalf("got %v, want nothing submitted", got)
-	}
-}
--- a/internal/ui/commands.go
+++ b/internal/ui/commands.go
@@ -30,14 +30,8 @@ func (c *Commands) Cancel() { c.Submit("/cancel") }
 // Skip — пропустить сбор, сформировать черновик (/skip).
 func (c *Commands) Skip() { c.Submit("/skip") }

-// Retry — перезапустить задачу N (/retry N): полный аналог Telegram-команды.
-// id <= 0 — no-op (кнопка «Перезапустить» на свободной вкладке неактивна).
-func (c *Commands) Retry(id int64) {
-	if id <= 0 {
-		return
-	}
-	c.Submit(fmt.Sprintf("/retry %d", id))
-}
+// Retry — перезапустить задачу N (/retry N).
+func (c *Commands) Retry(id int64) { c.Submit(fmt.Sprintf("/retry %d", id)) }

 // Status — запросить статус задачи N (/status N).
 func (c *Commands) Status(id int64) { c.Submit(fmt.Sprintf("/status %d", id)) }
--- a/internal/ui/desktop/chat_panel.go
+++ b/internal/ui/desktop/chat_panel.go
@@ -1,112 +0,0 @@
-//go:build cgo
-
-package desktop
-
-import (
-	"strings"
-
-	"fyne.io/fyne/v2"
-	"fyne.io/fyne/v2/container"
-	"fyne.io/fyne/v2/widget"
-
-	"github.com/kamelion/ratatoskr-go/internal/ui"
-)
-
-// chatLimit — обрезка буфера транскрипта диалога (спец 12.12).
-const chatLimit = 200_000
-
-// ChatPanel — Fyne-реализация ui.ChatPanel (спец 12.8, 12.12): транскрипт
-// диалога + композитор (поле ввода и кнопки команд).
-type ChatPanel struct {
-	convLbl   *widget.Label
-	input     *widget.Entry
-	commands  *ui.Commands
-	retryBtn  *widget.Button // «Перезапустить» — полный аналог /retry N
-	boundTask int64          // >0 — вкладка привязана к задаче №boundTask
-}
-
-// NewChatPanel создаёт ChatPanel.
-func NewChatPanel() *ChatPanel {
-	p := &ChatPanel{}
-	p.convLbl = widget.NewLabel("Выберите задачу.")
-	p.convLbl.Wrapping = fyne.TextWrapWord
-	p.input = widget.NewEntry()
-	p.input.SetPlaceHolder("Сообщение… (Enter — отправить)")
-	p.retryBtn = widget.NewButton("Перезапустить", p.retryTask)
-	p.retryBtn.Disable() // активируется при привязке вкладки к задаче (SetBoundTask)
-	return p
-}
-
-// Transcript возвращает виджет транскрипта (Scroll) для встраивания в окно.
-func (p *ChatPanel) Transcript() fyne.CanvasObject {
-	return container.NewScroll(p.convLbl)
-}
-
-// Composer возвращает виджет композитора (ввод + кнопки команд).
-func (p *ChatPanel) Composer() fyne.CanvasObject {
-	cmdBar := container.NewHBox(
-		widget.NewButton("Новая", func() { if p.commands != nil { p.commands.Start() } }),
-		widget.NewButton("Создавай", func() { if p.commands != nil { p.commands.Approve() } }),
-		widget.NewButton("Пропустить", func() { if p.commands != nil { p.commands.Skip() } }),
-		p.retryBtn,
-		widget.NewButton("Отмена", func() { if p.commands != nil { p.commands.Cancel() } }),
-	)
-	return container.NewBorder(nil, nil, cmdBar, nil, p.input)
-}
-
-// retryTask — колбэк кнопки «Перезапустить»: отправляет "/retry N" тем же
-// путём, что и ввод пользователя (Commands → Router → Core), т.е. серверная
-// логика полностью совпадает с Telegram-командой /retry N.
-func (p *ChatPanel) retryTask() {
-	if p.commands != nil {
-		p.commands.Retry(p.boundTask)
-	}
-}
-
-// SetBoundTask включает кнопку «Перезапустить», когда вкладка привязана к
-// задаче (taskID > 0); для свободной вкладки кнопка неактивна.
-func (p *ChatPanel) SetBoundTask(taskID int64) {
-	p.boundTask = taskID
-	if taskID > 0 {
-		p.retryBtn.Enable()
-	} else {
-		p.retryBtn.Disable()
-	}
-}
-
-// SetTranscript заменяет содержимое диалога (спец 12.12).
-func (p *ChatPanel) SetTranscript(text string) {
-	p.convLbl.SetText(text)
-}
-
-// Append добавляет строку в диалог (буфер ограничен).
-func (p *ChatPanel) Append(text string) {
-	s := p.convLbl.Text + text + "\n\n"
-	if len(s) > chatLimit {
-		s = s[len(s)-chatLimit:]
-	}
-	p.convLbl.SetText(s)
-}
-
-// Clear очищает диалог.
-func (p *ChatPanel) Clear() {
-	p.convLbl.SetText("")
-}
-
-// SetCommands подключает команды к композитору.
-func (p *ChatPanel) SetCommands(c *ui.Commands) {
-	p.commands = c
-	p.input.OnSubmitted = func(s string) {
-		s = strings.TrimSpace(s)
-		if s == "" {
-			return
-		}
-		p.input.SetText("")
-		if c != nil {
-			c.SendText(s)
-		}
-	}
-}
-
-// compile-time проверка реализации контракта.
-var _ ui.ChatPanel = (*ChatPanel)(nil)
--- a/internal/ui/desktop/log_panel.go
+++ b/internal/ui/desktop/log_panel.go
@@ -1,193 +0,0 @@
-//go:build cgo
-
-package desktop
-
-import (
-	"strings"
-	"time"
-
-	"fyne.io/fyne/v2"
-	"fyne.io/fyne/v2/container"
-	"fyne.io/fyne/v2/widget"
-
-	"github.com/kamelion/ratatoskr-go/internal/ui"
-)
-
-// maxLogBytes — кап суммарного объёма текста буфера «Логи» (байты), чтобы
-// не расти бесконечно и не копить мегабайты в памяти.
-const maxLogBytes = 10 * 1024 * 1024
-
-// renderFlushMs — дебаунс-интервал перерисовки ленты (мс): при всплеске
-// логов рендер выполняется не на каждую запись, а раз в этот интервал.
-const renderFlushMs = 200
-
-// LogPanel — Fyne-реализация ui.LogPanel (спец 12.8, 12.9): поток системных
-// логов с фильтром по уровням (error/warning/info/debug).
-//
-// Записи хранятся в ui.LogBuffer (ограниченный буфер); лента показывает
-// только записи уровней, отмеченных в фильтре (по умолчанию отмечены все).
-// Фильтр — выпадающий список с чекбоксами: кнопка над лентой открывает
-// widget.PopUp с widget.Check по каждому уровню; изменение набора сразу
-// перерисовывает ленту — и по уже загруженным записям, и для новых.
-//
-// Состояние (buf/selected/pending/flushScheduled/lastFlush) доступается только
-// с потока Fyne: Append приходит из горутин Hub и заворачивается в fyne.Do,
-// колбэки чекбоксов Fyne вызывает сам на своём потоке. Перерисовка ленты
-// коалесцируется (см. scheduleFlush), т.к. строка ленты пересобирается
-// целиком и при капе в 10MB на каждый append была бы дорогой.
-type LogPanel struct {
-	label *widget.Label
-	btn   *widget.Button // кнопка-дропдаун фильтра уровней
-
-	buf      *ui.LogBuffer   // буфер записей, старые вытесняются
-	selected map[string]bool // уровень → показывать (по умолчанию все)
-
-	pending        bool  // буфер изменился, рендер отложен (поток Fyne)
-	flushScheduled bool  // фоновый флаш уже запущен (поток Fyne)
-	lastFlush      int64 // мс последнего рендера (поток Fyne)
-}
-
-// NewLogPanel создаёт LogPanel с уровнями error/warning/info (debug скрыт).
-func NewLogPanel() *LogPanel {
-	p := &LogPanel{
-		buf:      ui.NewLogBuffer(maxLogBytes),
-		selected: make(map[string]bool, len(ui.LogLevels)),
-	}
-	for _, lvl := range ui.LogLevels {
-		p.selected[lvl] = lvl != ui.LogLevelDebug
-	}
-
-	p.label = widget.NewLabel("")
-	p.label.Wrapping = fyne.TextWrapWord
-	p.btn = widget.NewButton(p.filterCaption(), p.showFilterPopUp)
-	return p
-}
-
-// Widget возвращает контейнер панели для встраивания в окно (таб «Логи»):
-// строка фильтра сверху, лента лога в скролле снизу.
-func (p *LogPanel) Widget() fyne.CanvasObject {
-	return container.NewBorder(
-		container.NewHBox(p.btn), nil, nil, nil,
-		container.NewScroll(p.label),
-	)
-}
-
-// Append добавляет запись лога (спец 12.9), с ограничением буфера.
-// Вызывается из горутин Hub → вся работа на потоке Fyne через fyne.Do.
-func (p *LogPanel) Append(level, text string) {
-	fyne.Do(func() {
-		lvl := ui.NormalizeLogLevel(level)
-		dropped := p.buf.Append(lvl, text)
-		// Перерисовка нужна, если запись видима или вытеснение задело ленту.
-		if p.selected[lvl] || dropped {
-			p.pending = true
-			p.scheduleFlush()
-		}
-	})
-}
-
-// scheduleFlush планирует отложенный рендер через renderFlushMs (или сразу,
-// если с прошлого рендера прошло больше интервала). Все вызовы — с потока
-// Fyne; фоновый поток только спит и по таймеру отправляет flush через fyne.Do,
-// поэтому защита от повторного планирования (flushScheduled) работает без
-// блокировок.
-func (p *LogPanel) scheduleFlush() {
-	if p.flushScheduled {
-		return
-	}
-	p.flushScheduled = true
-	delay := int64(renderFlushMs) - (time.Now().UnixMilli() - p.lastFlush)
-	if delay < 1 {
-		delay = 1
-	}
-	go func() {
-		time.Sleep(time.Duration(delay) * time.Millisecond)
-		fyne.Do(p.flush)
-	}()
-}
-
-// flush выполняет отложенную перерисовку ленты (на потоке Fyne).
-func (p *LogPanel) flush() {
-	p.flushScheduled = false
-	if p.pending {
-		p.pending = false
-		p.lastFlush = time.Now().UnixMilli()
-		p.render()
-	}
-}
-
-// render перерисовывает ленту: дописывает в label только новые видимые
-// записи (RenderNew). Если вытеснение задело уже выведенные записи (stale),
-// RenderNew возвращает полный текст — пересобираем label целиком. Так при
-// росте ленты мимо лимита флаш дешёвый (только дельта), а полная пересборка
-// происходит лишь по вытеснению/смене фильтра.
-func (p *LogPanel) render() {
-	delta, full := p.buf.RenderNew(p.selected)
-	if full {
-		p.label.SetText(delta)
-		return
-	}
-	if delta == "" {
-		return
-	}
-	cur := p.label.Text
-	if cur == "" {
-		p.label.SetText(delta)
-	} else {
-		p.label.SetText(cur + delta)
-	}
-}
-
-// setLevel включает/выключает показ уровня и сразу обновляет ленту.
-// Вызывается только с потока Fyne (колбэки чекбоксов). Смена набора уровней
-// меняет видимость уже выведенных записей, поэтому — полный пересбор.
-func (p *LogPanel) setLevel(level string, on bool) {
-	if p.selected[level] == on {
-		return
-	}
-	p.selected[level] = on
-	p.btn.SetText(p.filterCaption())
-	p.label.SetText(p.buf.Render(p.selected))
-	p.buf.ResetRendered()
-}
-
-// filterCaption — подпись кнопки-дропдауна: текущий выбранный набор уровней.
-func (p *LogPanel) filterCaption() string {
-	var chosen []string
-	for _, lvl := range ui.LogLevels {
-		if p.selected[lvl] {
-			chosen = append(chosen, lvl)
-		}
-	}
-	switch {
-	case len(chosen) == len(ui.LogLevels):
-		return "Уровни: все"
-	case len(chosen) == 0:
-		return "Уровни: нет"
-	default:
-		return "Уровни: " + strings.Join(chosen, "+")
-	}
-}
-
-// showFilterPopUp открывает выпадающий список с чекбоксами уровней под
-// кнопкой фильтра. Список пересобирается при каждом открытии — чекбоксы
-// всегда отражают актуальное состояние фильтра.
-func (p *LogPanel) showFilterPopUp() {
-	c := fyne.CurrentApp().Driver().CanvasForObject(p.btn)
-	if c == nil {
-		return // виджет ещё не встроен в окно
-	}
-	rows := make([]fyne.CanvasObject, 0, len(ui.LogLevels))
-	for _, lvl := range ui.LogLevels {
-		lvl := lvl
-		cb := widget.NewCheck(lvl, func(on bool) { p.setLevel(lvl, on) })
-		cb.SetChecked(p.selected[lvl])
-		rows = append(rows, cb)
-	}
-	pop := widget.NewPopUp(container.NewPadded(container.NewVBox(rows...)), c)
-	pos := fyne.CurrentApp().Driver().AbsolutePositionForObject(p.btn)
-	pop.ShowAtPosition(fyne.NewPos(pos.X, pos.Y+p.btn.Size().Height))
-}
-
-// compile-time проверка реализации контракта.
-var _ ui.LogPanel = (*LogPanel)(nil)
--- a/internal/ui/desktop/maximize_windows.go
+++ b/internal/ui/desktop/maximize_windows.go
@@ -1,48 +0,0 @@
-//go:build cgo
-
-package desktop
-
-import (
-	"os"
-	"syscall"
-	"unsafe"
-)
-
-// Нативный максимум окна через Win32.
-//
-// Fyne (v2.6) не даёт ни Move, ни Maximize у fyne.Window, поэтому разворот на
-// экран (над панелью задач) делаем напрямую через user32: находим HWND нашего
-// процесса через EnumWindows и вызываем ShowWindow(SW_MAXIMIZE).
-// Только Windows (платформа приложения по спеке — Windows).
-
-const (
-	swMaximize = 9
-)
-
-var (
-	user32                    = syscall.NewLazyDLL("user32.dll")
-	procEnumWindows           = user32.NewProc("EnumWindows")
-	procGetWindowThreadProcID = user32.NewProc("GetWindowThreadProcessId")
-	procIsWindowVisible       = user32.NewProc("IsWindowVisible")
-	procShowWindow            = user32.NewProc("ShowWindow")
-)
-
-func maximizeWindow() {
-	pid := uint32(os.Getpid())
-
-	cb := syscall.NewCallback(func(hwnd syscall.Handle, _ uintptr) uintptr {
-		var winPid uint32
-		procGetWindowThreadProcID.Call(uintptr(hwnd), uintptr(unsafe.Pointer(&winPid)))
-		if winPid != pid {
-			return 1 // continue перечисление
-		}
-		visible, _, _ := procIsWindowVisible.Call(uintptr(hwnd))
-		if visible == 0 {
-			return 1 // continue перечисление
-		}
-		procShowWindow.Call(uintptr(hwnd), swMaximize)
-		return 0 // остановить перечисление
-	})
-
-	procEnumWindows.Call(cb, 0)
-}
--- a/internal/ui/desktop/state_panel.go
+++ b/internal/ui/desktop/state_panel.go
@@ -1,50 +0,0 @@
-//go:build cgo
-
-package desktop
-
-import (
-	"fyne.io/fyne/v2"
-	"fyne.io/fyne/v2/container"
-	"fyne.io/fyne/v2/widget"
-
-	"github.com/kamelion/ratatoskr-go/internal/ui"
-)
-
-// stateLimit — обрезка буфера панели «Состояние» (спец 12.13).
-const stateLimit = 200_000
-
-// StatePanel — Fyne-реализация ui.StatePanel (спец 12.8, 12.13): агенты и
-// трейсы выбранной задачи (таб «Состояние»).
-type StatePanel struct {
-	stateLbl *widget.Label
-}
-
-// NewStatePanel создаёт StatePanel.
-func NewStatePanel() *StatePanel {
-	p := &StatePanel{}
-	p.stateLbl = widget.NewLabel("")
-	p.stateLbl.Wrapping = fyne.TextWrapWord
-	return p
-}
-
-// Widget возвращает контейнер панели для встраивания в таб «Состояние».
-func (p *StatePanel) Widget() fyne.CanvasObject {
-	return container.NewScroll(p.stateLbl)
-}
-
-// SetText заменяет содержимое снимком трасс (спец 12.13).
-func (p *StatePanel) SetText(text string) {
-	p.stateLbl.SetText(text)
-}
-
-// Append добавляет live-строку (буфер ограничен).
-func (p *StatePanel) Append(text string) {
-	s := p.stateLbl.Text + text + "\n"
-	if len(s) > stateLimit {
-		s = s[len(s)-stateLimit:]
-	}
-	p.stateLbl.SetText(s)
-}
-
-// compile-time проверка реализации контракта.
-var _ ui.StatePanel = (*StatePanel)(nil)
--- a/internal/ui/desktop/task_detail_panel.go
+++ b/internal/ui/desktop/task_detail_panel.go
@@ -1,54 +0,0 @@
-//go:build cgo
-
-package desktop
-
-import (
-	"fyne.io/fyne/v2"
-	"fyne.io/fyne/v2/container"
-	"fyne.io/fyne/v2/widget"
-
-	"github.com/kamelion/ratatoskr-go/internal/storage"
-	"github.com/kamelion/ratatoskr-go/internal/ui"
-)
-
-// TaskDetailPanel — Fyne-реализация ui.TaskDetailPanel (спец 12.8, 12.11):
-// детали выбранной задачи (заголовок, статус, детали) — верх right-сплита.
-type TaskDetailPanel struct {
-	titleLbl  *widget.Label
-	statusLbl *widget.Label
-	detailLbl *widget.Label
-}
-
-// NewTaskDetailPanel создаёт TaskDetailPanel.
-func NewTaskDetailPanel() *TaskDetailPanel {
-	p := &TaskDetailPanel{}
-	p.titleLbl = widget.NewLabel("—")
-	p.titleLbl.TextStyle = fyne.TextStyle{Bold: true}
-	p.statusLbl = widget.NewLabel("")
-	p.statusLbl.TextStyle = fyne.TextStyle{Italic: true}
-	p.detailLbl = widget.NewLabel("")
-	p.detailLbl.Wrapping = fyne.TextWrapWord
-	return p
-}
-
-// Widget возвращает контейнер панели для встраивания в окно (верх right-сплита).
-func (p *TaskDetailPanel) Widget() fyne.CanvasObject {
-	return container.NewVBox(p.titleLbl, p.statusLbl, p.detailLbl)
-}
-
-// ShowTask рендерит детали из снимка задачи (спец 12.11).
-func (p *TaskDetailPanel) ShowTask(t storage.Task) {
-	p.titleLbl.SetText(t.Title)
-	p.statusLbl.SetText(string(t.Status))
-	p.detailLbl.SetText(ui.TaskDetailText(t))
-}
-
-// ShowEmpty сбрасывает к placeholder при недоступной задаче.
-func (p *TaskDetailPanel) ShowEmpty() {
-	p.titleLbl.SetText("—")
-	p.statusLbl.SetText("")
-	p.detailLbl.SetText("")
-}
-
-// compile-time проверка реализации контракта.
-var _ ui.TaskDetailPanel = (*TaskDetailPanel)(nil)
--- a/internal/ui/desktop/task_list_panel.go
+++ b/internal/ui/desktop/task_list_panel.go
@@ -1,78 +0,0 @@
-//go:build cgo
-
-package desktop
-
-import (
-	"fyne.io/fyne/v2"
-	"fyne.io/fyne/v2/widget"
-
-	"github.com/kamelion/ratatoskr-go/internal/storage"
-	"github.com/kamelion/ratatoskr-go/internal/ui"
-)
-
-// TaskListPanel — Fyne-реализация ui.TaskListPanel (спец 12.8, 12.10): список
-// задач (левая панель окна).
-//
-// Внутри — widget.List над собственным буфером []storage.Task (снимки из Store).
-// Состояние выбора живёт в окне: окно зовёт Select, чтобы подсветить строку.
-type TaskListPanel struct {
-	list  *widget.List
-	tasks []storage.Task
-}
-
-// NewTaskListPanel создаёт TaskListPanel.
-func NewTaskListPanel() *TaskListPanel {
-	p := &TaskListPanel{}
-	p.list = widget.NewList(
-		func() int { return len(p.tasks) },
-		func() fyne.CanvasObject {
-			return widget.NewLabel("loading…")
-		},
-		func(id widget.ListItemID, o fyne.CanvasObject) {
-			if id < 0 || id >= len(p.tasks) {
-				return
-			}
-			o.(*widget.Label).SetText(ui.TaskTitle(p.tasks[id]))
-		},
-	)
-	return p
-}
-
-// Widget возвращает виджет списка для встраивания в окно (левая панель).
-func (p *TaskListPanel) Widget() fyne.CanvasObject {
-	return p.list
-}
-
-// SetTasks заменяет снимок списка и перерисовывает виджет (спец 12.10).
-func (p *TaskListPanel) SetTasks(tasks []storage.Task) {
-	p.tasks = tasks
-	p.list.Refresh()
-}
-
-// Select подсвечивает строку задачи id; если её нет — снимает выделение.
-func (p *TaskListPanel) Select(id int64) {
-	idx := -1
-	for i, t := range p.tasks {
-		if t.ID == id {
-			idx = i
-			break
-		}
-	}
-	if idx < 0 {
-		p.list.UnselectAll()
-		return
-	}
-	p.list.Select(widget.ListItemID(idx))
-}
-
-// OnSelect регистрирует колбэк клика по строке (спец 12.10).
-func (p *TaskListPanel) OnSelect(fn func(id int64)) {
-	p.list.OnSelected = func(id widget.ListItemID) {
-		if fn != nil && id >= 0 && id < len(p.tasks) {
-			fn(p.tasks[id].ID)
-		}
-	}
-}
-
-// compile-time проверка реализации контракта.
-var _ ui.TaskListPanel = (*TaskListPanel)(nil)
--- a/internal/ui/desktop/window.go
+++ b/internal/ui/desktop/window.go
@@ -8,9 +8,9 @@ package desktop

 import (
 	"context"
-	"fmt"
 	"log"
 	"strings"
+	"sync"

 	"fyne.io/fyne/v2"
 	"fyne.io/fyne/v2/app"
@@ -20,43 +20,44 @@ import (

 	"github.com/kamelion/ratatoskr-go/internal/chat"
 	"github.com/kamelion/ratatoskr-go/internal/events"
+	"github.com/kamelion/ratatoskr-go/internal/model"
+	"github.com/kamelion/ratatoskr-go/internal/storage"
 	"github.com/kamelion/ratatoskr-go/internal/ui"
 )

 const (
+	maxLogLen    = 200_000 // обрезка буферов панелей, чтобы не расти бесконечно
 	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

-	// состояние выбора (живёт в окне, спец 12.10)
+	// состояние списка
+	mu       sync.Mutex // защищает tasks
+	tasks    []storage.Task
 	selected int64

 	// виджеты
-	taskList *TaskListPanel
-	detail   *TaskDetailPanel
-	state    *StatePanel
-	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>
+	list      *widget.List
+	titleLbl  *widget.Label
+	statusLbl *widget.Label
+	detailLbl *widget.Label
+	convLbl   *widget.Label
+	logsLbl   *widget.Label
+	stateLbl  *widget.Label
+	input     *widget.Entry

 	hsplit *container.Split
+	vsplit *container.Split

 	onQuit func()
 }
@@ -67,11 +68,10 @@ func New(appID string, store ui.Store) *Window {
 	w := &Window{
 		fyneApp: fa,
 		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 продолжает работать.
@@ -87,13 +87,48 @@ func (w *Window) SetOnQuit(fn func()) { w.onQuit = fn }

 // build собирает виджеты и раскладку.
 func (w *Window) build() {
-	w.detail = NewTaskDetailPanel()
-	w.state = NewStatePanel()
-	w.logs = NewLogPanel()
+	w.titleLbl = widget.NewLabel("—")
+	w.titleLbl.TextStyle = fyne.TextStyle{Bold: true}
+	w.statusLbl = widget.NewLabel("")
+	w.statusLbl.TextStyle = fyne.TextStyle{Italic: true}
+	w.detailLbl = widget.NewLabel("")
+	w.detailLbl.Wrapping = fyne.TextWrapWord
+
+	w.convLbl = widget.NewLabel("Выберите задачу.")
+	w.convLbl.Wrapping = fyne.TextWrapWord
+
+	w.logsLbl = widget.NewLabel("")
+	w.logsLbl.Wrapping = fyne.TextWrapWord
+
+	w.stateLbl = widget.NewLabel("")
+	w.stateLbl.Wrapping = fyne.TextWrapWord

 	// Список задач (слева)
-	w.taskList = NewTaskListPanel()
-	w.taskList.OnSelect(func(id int64) { w.openTaskTab(id) })
+	w.list = widget.NewList(
+		func() int { w.mu.Lock(); defer w.mu.Unlock(); return len(w.tasks) },
+		func() fyne.CanvasObject {
+			return widget.NewLabel("loading…")
+		},
+		func(id widget.ListItemID, o fyne.CanvasObject) {
+			w.mu.Lock()
+			defer w.mu.Unlock()
+			if id < 0 || id >= len(w.tasks) {
+				return
+			}
+			t := w.tasks[id]
+			o.(*widget.Label).SetText(taskTitle(t))
+		},
+	)
+	w.list.OnSelected = func(id widget.ListItemID) {
+		w.mu.Lock()
+		if id < 0 || id >= len(w.tasks) {
+			w.mu.Unlock()
+			return
+		}
+		t := w.tasks[id]
+		w.mu.Unlock()
+		w.selectTask(t.ID)
+	}

 	quitBtn := widget.NewButtonWithIcon("Завершить", theme.LogoutIcon(), func() {
 		w.saveLayout()
@@ -101,130 +136,104 @@ func (w *Window) build() {
 			w.onQuit()
 		}
 	})
-	left := container.NewBorder(nil, quitBtn, nil, nil, w.taskList.Widget())
+	left := container.NewBorder(nil, quitBtn, nil, nil, w.list)

-	// Центр: вкладки-сессии + кнопка «Новый чат».
-	w.tabs = container.NewAppTabs()
-	w.tabs.OnSelected = func(tab *container.TabItem) {
-		// фокус вкладки → показываем детали/состояние её задачи
-		if s := w.tabSession[tab]; s != nil && s.BoundTask > 0 {
-			w.selectTask(s.BoundTask)
-		}
-	}
-	newBtn := widget.NewButtonWithIcon("Новый чат", theme.ContentAddIcon(), func() {
-		w.addFreeTab()
-	})
-	center := container.NewBorder(newBtn, nil, nil, nil, w.tabs)
+	// Рабочая область: детали сверху, диалог снизу (сплит 2×2 в плане).
+	details := container.NewVBox(w.titleLbl, w.statusLbl, w.detailLbl)
+	convScroll := container.NewScroll(w.convLbl)
+	right := container.NewVSplit(
+		container.NewScroll(details),
+		convScroll,
+	)
+	w.vsplit = right

 	// Нижняя панель: вкладки «Логи» + «Состояние».
 	bottomTabs := container.NewAppTabs(
-		container.NewTabItem("Логи", w.logs.Widget()),
-		container.NewTabItem("Состояние", w.state.Widget()),
+		container.NewTabItem("Логи", container.NewScroll(w.logsLbl)),
+		container.NewTabItem("Состояние", container.NewScroll(w.stateLbl)),
 	)
-	bottom := container.NewBorder(nil, nil, nil, nil, bottomTabs)

-	w.hsplit = container.NewHSplit(left, container.NewVSplit(center, bottom))
-	w.win.SetContent(w.hsplit)
+	// Ввод + кнопки команд
+	w.input = widget.NewEntry()
+	w.input.SetPlaceHolder("Сообщение… (Enter — отправить)")
+	w.input.OnSubmitted = func(s string) {
+		s = strings.TrimSpace(s)
+		if s == "" {
+			return
+		}
+		w.input.SetText("")
+		w.commands.SendText(s)
+	}
+	cmdBar := container.NewHBox(
+		widget.NewButton("Новая", func() { w.commands.Start() }),
+		widget.NewButton("Создавай", func() { w.commands.Approve() }),
+		widget.NewButton("Пропустить", func() { w.commands.Skip() }),
+		widget.NewButton("Отмена", func() { w.commands.Cancel() }),
+	)
+	inputRow := container.NewBorder(nil, nil, cmdBar, w.input, nil)
+	bottom := container.NewBorder(nil, inputRow, nil, nil, bottomTabs)
+
+	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()
 }

-// addFreeTab создаёт свободную вкладку-сессию (in-memory диалог с LLM).
-func (w *Window) addFreeTab() {
-	w.nextSess++
-	id := fmt.Sprintf("%s%d", ui.SessionID, w.nextSess)
-	w.addTab(ui.NewFreeSession(chat.UserID(id), chat.Address(id)))
+// saveLayout сохраняет текущие позиции сплитов в Preferences.
+// Вызывается при сворачивании окна и перед полным выходом.
+func (w *Window) saveLayout() {
+	pref := w.fyneApp.Preferences()
+	pref.SetFloat(splitHPref, w.hsplit.Offset)
+	pref.SetFloat(splitVPref, w.vsplit.Offset)
 }

-// addTab создаёт вкладку для сессии и фокусирует её.
-func (w *Window) addTab(sess *ui.Session) {
-	panel := NewChatPanel()
-	panel.SetCommands(ui.NewCommands(func(text string) {
-		w.submitText(sess.UserID, sess.Address, text)
-	}))
-	// Кнопка «Перезапустить» активна только у вкладки с задачей (/retry N).
-	panel.SetBoundTask(sess.BoundTask)
-
-	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)
+// taskTitle — строка в списке задач.
+func taskTitle(t storage.Task) string {
+	title := t.Title
+	if title == "" {
+		title = "(без названия)"
+	}
+	return title + "\n" + string(t.Status)
 }

-// tabForAddress возвращает вкладку по адресу сессии.
-func (w *Window) tabForAddress(addr chat.Address) *container.TabItem {
-	for tab, s := range w.tabSession {
-		if s.Address == addr {
-			return tab
-		}
-	}
-	return nil
-}
+// selectTask загружает детали выбранной задачи (снимки из Store).
+func (w *Window) selectTask(id int64) {
+	w.selected = id
+	w.fyneApp.Preferences().SetInt(selectedPref, int(id))

-// 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.titleLbl.SetText("—")
+		w.statusLbl.SetText("")
+		w.detailLbl.SetText("")
+		w.convLbl.SetText("")
 		return
 	}
+	w.titleLbl.SetText(t.Title)
+	w.statusLbl.SetText(string(t.Status))
+	detail := "Цель: " + t.Goal
+	if len(t.Repos) > 0 {
+		detail += "\nРепозитории: " + strings.Join(t.Repos, ", ")
+	}
+	w.detailLbl.SetText(detail)

-	// 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
 	}
 	var b strings.Builder
 	for _, h := range hist {
-		b.WriteString(ui.FormatRole(h.Role))
+		b.WriteString(formatRole(h.Role))
 		b.WriteString(h.Content)
 		b.WriteString("\n\n")
 	}
@@ -237,40 +246,39 @@ func (w *Window) renderHistory(ctx context.Context, id int64) string {
 	if b.Len() == 0 {
 		b.WriteString("Нет сообщений. /start — начать задачу.")
 	}
-	return b.String()
-}
+	w.convLbl.SetText(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)
 }

+func formatRole(role string) string {
+	switch role {
+	case "user":
+		return "👤 "
+	default:
+		return "🤖 "
+	}
+}
+
 // refreshState — снимок «Состояния» выбранной задачи (агенты + трейсы).
 func (w *Window) refreshState(ctx context.Context, id int64) {
 	traces, err := w.store.GetTraces(ctx, id)
 	if err != nil {
 		return
 	}
-	w.state.SetText(ui.StateText(traces))
+	var b strings.Builder
+	for _, tr := range traces {
+		b.WriteString(strings.ToUpper(tr.Agent) + ": " + string(tr.Status))
+		if tr.SessionID != "" {
+			b.WriteString(" (session " + tr.SessionID + ")")
+		}
+		b.WriteString("\n")
+	}
+	if b.Len() == 0 {
+		b.WriteString("Нет активных агентов.")
+	}
+	w.stateLbl.SetText(b.String())
 }

 // refreshList перечитывает список задач из Store (снимок).
@@ -281,46 +289,56 @@ func (w *Window) refreshList() {
 		log.Printf("ui: list tasks: %v", err)
 		return
 	}
-	w.taskList.SetTasks(tasks)
-	w.taskList.Select(w.selected)
+	w.mu.Lock()
+	w.tasks = tasks
+	selected := w.selected
+	w.mu.Unlock()
+
+	if w.list != nil {
+		w.list.Refresh()
+	}
+	_ = selected
 }

-// appendLog добавляет запись в панель «Логи» (делегирует в LogPanel).
-func (w *Window) appendLog(level, text string) {
-	w.logs.Append(level, text)
+// appendConv добавляет строку в диалог (буфер ограничен).
+func (w *Window) appendConv(text string) {
+	s := w.convLbl.Text + text + "\n\n"
+	if len(s) > maxLogLen {
+		s = s[len(s)-maxLogLen:]
+	}
+	w.convLbl.SetText(s)
 }

-// submitText отправляет ввод пользователя из вкладки в Router.
-func (w *Window) submitText(uid chat.UserID, addr chat.Address, text string) {
+// appendLog добавляет строку в панель «Логи».
+func (w *Window) appendLog(text string) {
+	s := w.logsLbl.Text + text + "\n"
+	if len(s) > maxLogLen {
+		s = s[len(s)-maxLogLen:]
+	}
+	w.logsLbl.SetText(s)
+}
+
+// appendState добавляет строку в панель «Состояние».
+func (w *Window) appendState(text string) {
+	s := w.stateLbl.Text + text + "\n"
+	if len(s) > maxLogLen {
+		s = s[len(s)-maxLogLen:]
+	}
+	w.stateLbl.SetText(s)
+}
+
+// submitText отправляет ввод пользователя в Router.
+func (w *Window) submitText(text string) {
 	if w.handler != nil {
 		w.handler(chat.Incoming{
-			UserID:  uid,
-			Address: addr,
+			UserID:  ui.UID,
+			Address: ui.Address,
 			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 panel := w.panels[addr]; panel != nil {
-			panel.SetBoundTask(taskID)
-		}
-		if tab := w.tabForAddress(addr); tab != nil {
-			tab.Text = "Задача #" + ui.Itoa(taskID)
-			w.tabs.Refresh()
-		}
-	}
-}
-
 // ---- chat.Channel ----

 // OnMessage регистрирует обработчик входящих (Router).
@@ -329,7 +347,6 @@ func (w *Window) OnMessage(h chat.Handler) { w.handler = h }
 // Run показывает окно и запускает Fyne-цикл. Блокирует до Quit.
 func (w *Window) Run(ctx context.Context) error {
 	w.win.Show()
-	maximizeWindow()
 	go func() {
 		<-ctx.Done()
 		w.fyneApp.Quit()
@@ -338,37 +355,30 @@ func (w *Window) Run(ctx context.Context) error {
 	return nil
 }

-// Send доставляет сообщение Core в диалог вкладки по её Address.
-func (w *Window) Send(_ context.Context, to chat.Address, m chat.Message) error {
-	panel, ok := w.panels[to]
-	if !ok {
-		return nil
-	}
+// Send доставляет сообщение Core в диалог окна.
+func (w *Window) Send(_ context.Context, _ chat.Address, m chat.Message) error {
 	text := m.Text
 	if len(m.Options) > 0 {
 		var sb strings.Builder
 		sb.WriteString(text)
-		for _, opt := range m.Options {
+		for i, opt := range m.Options {
 			sb.WriteString("\n")
 			sb.WriteString(opt.Label)
+			_ = i
 		}
 		text = sb.String()
 	}
-	fyne.Do(func() { panel.Append("🤖 " + text) })
+	fyne.Do(func() { w.appendConv("🤖 " + text) })
 	return nil
 }

-// Ask — вопрос с вариантами (отображается в диалоге вкладки).
-func (w *Window) Ask(_ context.Context, to chat.Address, m chat.Message) error {
-	panel, ok := w.panels[to]
-	if !ok {
-		return nil
-	}
+// Ask — вопрос с вариантами (отображается в диалоге).
+func (w *Window) Ask(_ context.Context, _ chat.Address, m chat.Message) error {
 	text := m.Text
 	for _, opt := range m.Options {
 		text += "\n" + opt.Label
 	}
-	fyne.Do(func() { panel.Append("❓ " + text) })
+	fyne.Do(func() { w.appendConv("❓ " + text) })
 	return nil
 }

@@ -385,8 +395,6 @@ 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)
 		}
@@ -417,41 +425,73 @@ func (w *Window) OnTaskStatusChanged(e events.TaskStatusChanged) {
 		if w.selected == e.ID {
 			w.selectTask(e.ID)
 		}
-		w.state.Append(ui.TaskStatusText(e))
+		w.appendState(taskStatusLine(e))
 	})
 }

 func (w *Window) OnHistoryAppended(e events.HistoryAppended) {
 	fyne.Do(func() {
-		// история приходит в диалог вкладки задачи
-		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)
-				}
-			}
+		if w.selected == e.TaskID {
+			w.appendConv(formatRole(e.Role) + e.Content)
 		}
 	})
 }

 func (w *Window) OnTraceAppended(e events.TraceAppended) {
 	fyne.Do(func() {
-		w.state.Append(ui.TraceLine(e.Agent, e.Status))
+		w.appendState(strings.ToUpper(e.Agent) + ": " + string(e.Status))
 	})
 }

 func (w *Window) OnAgentActivity(e events.AgentActivity) {
 	fyne.Do(func() {
-		w.state.Append(ui.ActivityLine(e.Agent, e.Stage))
+		w.appendState(strings.ToUpper(e.Agent) + " → " + e.Stage)
 	})
 }

 func (w *Window) OnLog(e events.LogLine) {
-	w.appendLog(e.Level, e.Text)
+	fyne.Do(func() { w.appendLog(e.Text) })
 }

-// compile-time проверка: окно реализует chat.Channel и ui.View.
-var (
-	_ chat.Channel = (*Window)(nil)
-	_ ui.View      = (*Window)(nil)
-)
+func taskStatusLine(e events.TaskStatusChanged) string {
+	return statusBadge(e.To) + " #" + itoa(e.ID) + ": " + string(e.From) + " → " + string(e.To)
+}
+
+func statusBadge(s model.Status) string {
+	switch s {
+	case model.StatusSuccess:
+		return "✅"
+	case model.StatusFailed, model.StatusAborted:
+		return "❌"
+	case model.StatusRunning, model.StatusCollecting:
+		return "⏳"
+	case model.StatusReady, model.StatusApproved:
+		return "🟡"
+	case model.StatusCancelled:
+		return "🚫"
+	default:
+		return "•"
+	}
+}
+
+func itoa(v int64) string {
+	if v == 0 {
+		return "0"
+	}
+	neg := v < 0
+	if neg {
+		v = -v
+	}
+	var b [24]byte
+	i := len(b)
+	for v > 0 {
+		i--
+		b[i] = byte('0' + v%10)
+		v /= 10
+	}
+	if neg {
+		i--
+		b[i] = '-'
+	}
+	return string(b[i:])
+}
--- a/internal/ui/log_panel.go
+++ b/internal/ui/log_panel.go
@@ -1,226 +0,0 @@
-// Package ui — контроллер и представления десктопного интерфейса (Fyne).
-//
-// Слой обмена с ядром: однонаправленный поток (спец 12.2–12.5).
-//   - Core мутирует состояние; UI только читает снимки и реагирует на события.
-//   - Действия UI = команды (CreateTask/ApproveTask/...), которые зовут Core.
-//   - Подписчик шины (Controller) получает события и перекладывает их в View
-//     (реализация Fyne) через fyne.Do — никаких прямых вызовов Fyne из core.
-//
-// Контракты компонентов-виджетов (спец 12.8): интерфейс + Nil-реализация.
-package ui
-
-import "strings"
-
-// Канонические уровни записей лога для фильтра панели «Логи» (спец 12.9).
-const (
-	LogLevelError   = "error"
-	LogLevelWarning = "warning"
-	LogLevelInfo    = "info"
-	LogLevelDebug   = "debug"
-)
-
-// LogLevels — уровни в порядке их вывода в фильтре виджета «Логи».
-var LogLevels = []string{LogLevelError, LogLevelWarning, LogLevelInfo, LogLevelDebug}
-
-// NormalizeLogLevel приводит уровень записи лога к одному из канонических
-// уровней (LogLevels). Синонимы маппятся на ближайший уровень (err/fatal →
-// error, warn → warning, trace → debug); пустые и неизвестные значения
-// ("log" от events.LogWriter и всё прочее) считаются информационными.
-func NormalizeLogLevel(level string) string {
-	switch strings.ToLower(strings.TrimSpace(level)) {
-	case LogLevelError, "err", "fatal":
-		return LogLevelError
-	case LogLevelWarning, "warn":
-		return LogLevelWarning
-	case LogLevelDebug, "trace":
-		return LogLevelDebug
-	default:
-		return LogLevelInfo
-	}
-}
-
-// LogPanel — панель «Логи» (спец 12.9): поток системных логов с уровнями.
-//
-// Хранит записи (уровень + строка) в буфере ограниченного размера; при
-// превышении лимита старые записи отбрасываются. Реализация обязана
-// поддерживать фильтр по уровням: выпадающий список с чекбоксами
-// (error/warning/info/debug), по умолчанию отмечены все уровни; показываются
-// только записи выбранных уровней, изменение набора сразу обновляет ленту.
-// Контейнер виджета отдаётся окну для встраивания в таб «Логи» — реализация
-// (Fyne) сама владеет своим виджетом.
-type LogPanel interface {
-	// Append добавляет запись лога: level — уровень из events.LogLine
-	// (нормализуется через NormalizeLogLevel), text — строка лога.
-	// Реализация обязана перекладывать работу на поток Fyne (fyne.Do /
-	// fyne.DoAndWait), т.к. вызывается из горутин Hub.
-	Append(level, text string)
-}
-
-// NilLogPanel — no-op реализация LogPanel для headless-режима и тестов.
-type NilLogPanel struct{}
-
-// NewNilLogPanel создаёт NilLogPanel.
-func NewNilLogPanel() *NilLogPanel { return &NilLogPanel{} }
-
-func (NilLogPanel) Append(string, string) {}
-
-// LogEntry — запись буфера панели «Логи»: канонический уровень + строка.
-type LogEntry struct {
-	Level string
-	Text  string
-}
-
-// compactThreshold — порог, при котором «мёртвые» (вытесненные сдвигом)
-// записи физически убираются из буфера пачкой. Вытеснение лениво: оно лишь
-// инкрементирует start, поэтому не копирует хвост массива на каждую
-// вытесненную запись (иначе trim был бы O(n²)). Уборка выполняется редко.
-const compactThreshold = 256
-
-// LogBuffer — ограниченный буфер записей лога с фильтрацией по уровням
-// (спец 12.9). Чистая логика без Fyne: используется Fyne-реализацией
-// LogPanel и тестируется в internal/ui.
-//
-// Не синхронизирована: потокобезопасность обеспечивает владелец (все вызовы
-// на потоке Fyne).
-type LogBuffer struct {
-	entries []LogEntry
-	start   int // индекс первого «живого» элемента (ленивое вытеснение)
-	total   int // суммарный объём текста живых записей [start..], байты
-	maxLen  int // лимит суммарного объёма текста записей, байты
-
-	// Инкрементальная отрисовка (RenderNew): rendered — сколько живых записей
-	// от начала уже выведено в текст ленты; stale — вытеснение задело уже
-	// выведенные записи, так что текст ленты нельзя дополнить дельтом и нужен
-	// полный пересбор. Эти поля поддерживаются только рендером.
-	rendered int
-	stale    bool
-}
-
-// NewLogBuffer создаёт буфер ёмкостью maxLen байт текста записей.
-func NewLogBuffer(maxLen int) *LogBuffer {
-	return &LogBuffer{maxLen: maxLen}
-}
-
-// Append добавляет запись (уровень нормализуется через NormalizeLogLevel,
-// хвостовые переводы строк срезаются). При превышении лимита старые записи
-// вытесняются. Сообщает, было ли вытеснение/обрезка — владелец должен
-// перерисовать ленту, даже если новая запись не видима.
-func (b *LogBuffer) Append(level, text string) bool {
-	b.entries = append(b.entries, LogEntry{
-		Level: NormalizeLogLevel(level),
-		Text:  strings.TrimRight(text, "\r\n"),
-	})
-	b.total += len(b.entries[len(b.entries)-1].Text) + 1
-	return b.trim()
-}
-
-// trim удерживает суммарный объём текста живых записей в пределах maxLen,
-// лениво вытесняя старые (инкремент start); одиночная запись длиннее лимита
-// обрезается до последних maxLen байт. Сообщает, было ли вытеснение/обрезка.
-func (b *LogBuffer) trim() bool {
-	dropped := false
-	live := len(b.entries) - b.start
-	evicted := 0
-	for b.total > b.maxLen && live > 1 {
-		b.total -= len(b.entries[b.start].Text) + 1
-		b.start++
-		live--
-		evicted++
-		dropped = true
-	}
-	// Если вытеснена хотя бы одна уже выведенная запись (b.rendered), текст
-	// ленты устарел: дельта не может убрать верхние строки, нужен полный
-	// пересбор. rendered при этом уменьшается на число вытесненных.
-	if evicted > 0 && b.rendered > 0 {
-		b.stale = true
-	}
-	if evicted >= b.rendered {
-		b.rendered = 0
-	} else {
-		b.rendered -= evicted
-	}
-	// Компакция «мёртвых» записей пачкой, а не на каждом append.
-	if b.start >= compactThreshold {
-		b.entries = b.entries[b.start:]
-		b.start = 0
-	}
-	if n := len(b.entries); n > b.start && len(b.entries[n-1].Text) > b.maxLen {
-		// Обрезка последней записи меняет уже выведенный текст, если она
-		// была отрисована.
-		if b.rendered == n-b.start {
-			b.stale = true
-		}
-		b.entries[n-1].Text = b.entries[n-1].Text[len(b.entries[n-1].Text)-b.maxLen:]
-		b.total = b.maxLen + 1
-		dropped = true
-	}
-	return dropped
-}
-
-// Entries возвращает копию списка живых записей буфера.
-func (b *LogBuffer) Entries() []LogEntry {
-	out := make([]LogEntry, len(b.entries)-b.start)
-	copy(out, b.entries[b.start:])
-	return out
-}
-
-// Render строит текст ленты только из живых записей уровней, отмеченных в
-// selected (уровень → показывать). Пустой или nil набор → пустая лента.
-// Полный рендер: используется для первичной отрисовки и после смены фильтра.
-func (b *LogBuffer) Render(selected map[string]bool) string {
-	if selected == nil {
-		return ""
-	}
-	return b.renderFrom(b.start, selected)
-}
-
-// ResetRendered помечает все живые записи как уже выведенные. Зовётся после
-// полного рендера (SetText(Render)), чтобы следующий RenderNew вернул только
-// новые записи.
-func (b *LogBuffer) ResetRendered() {
-	b.rendered = len(b.entries) - b.start
-	b.stale = false
-}
-
-// RenderNew отдаёт текст ещё не выведенных видимых записей и флаг, требует
-// ли слой полного пересбора ленты. Если вытеснение задело уже выведенные
-// записи (stale), возвращаемый текст — полный рендер с нуля (и флаг true), а
-// не дельта. Иначе — только текст новых записей, которым можно дополнить
-// текущий текст ленты.
-func (b *LogBuffer) RenderNew(selected map[string]bool) (text string, full bool) {
-	if selected == nil {
-		return "", false
-	}
-	live := len(b.entries) - b.start
-	if b.stale {
-		b.stale = false
-		b.rendered = live
-		return b.renderFrom(b.start, selected), true
-	}
-	from := b.start + b.rendered
-	var s strings.Builder
-	for i := from; i < len(b.entries); i++ {
-		e := b.entries[i]
-		if !selected[e.Level] {
-			continue
-		}
-		s.WriteString(e.Text)
-		s.WriteByte('\n')
-	}
-	b.rendered = live
-	return s.String(), false
-}
-
-// renderFrom строит текст записей, начиная с индекса from, с учётом selected.
-func (b *LogBuffer) renderFrom(from int, selected map[string]bool) string {
-	var s strings.Builder
-	for i := from; i < len(b.entries); i++ {
-		e := b.entries[i]
-		if !selected[e.Level] {
-			continue
-		}
-		s.WriteString(e.Text)
-		s.WriteByte('\n')
-	}
-	return s.String()
-}
--- a/internal/ui/log_panel_test.go
+++ b/internal/ui/log_panel_test.go
@@ -1,320 +0,0 @@
-package ui
-
-import "testing"
-
-// NilLogPanel — no-op контракт (спец 12.8): Append ничего не делает, безопасно
-// вызывается из горутин Hub и из тестов без Fyne.
-func TestNilLogPanelAppendNoop(t *testing.T) {
-	p := NewNilLogPanel()
-	p.Append(LogLevelError, "line 1")
-	p.Append("", "")
-	p.Append(LogLevelDebug, "line 3")
-}
-
-// NormalizeLogLevel приводит любые уровни к каноническим четырём:
-// синонимы маппятся, неизвестные/пустые значения считаются info.
-func TestNormalizeLogLevel(t *testing.T) {
-	cases := []struct {
-		in   string
-		want string
-	}{
-		{LogLevelError, LogLevelError},
-		{"ERROR", LogLevelError},
-		{" err ", LogLevelError},
-		{"fatal", LogLevelError},
-		{LogLevelWarning, LogLevelWarning},
-		{"WARN", LogLevelWarning},
-		{"Warning", LogLevelWarning},
-		{LogLevelInfo, LogLevelInfo},
-		{"INFO", LogLevelInfo},
-		{LogLevelDebug, LogLevelDebug},
-		{"DEBUG", LogLevelDebug},
-		{"trace", LogLevelDebug},
-		// события LogWriter без явного уровня и прочий мусор → info
-		{"log", LogLevelInfo},
-		{"", LogLevelInfo},
-		{"  ", LogLevelInfo},
-		{"unknown", LogLevelInfo},
-	}
-	for _, c := range cases {
-		if got := NormalizeLogLevel(c.in); got != c.want {
-			t.Errorf("NormalizeLogLevel(%q) = %q, want %q", c.in, got, c.want)
-		}
-	}
-}
-
-// LogLevels — ровно четыре уровня фильтра в фиксированном порядке.
-func TestLogLevelsContract(t *testing.T) {
-	want := []string{LogLevelError, LogLevelWarning, LogLevelInfo, LogLevelDebug}
-	if len(LogLevels) != len(want) {
-		t.Fatalf("len(LogLevels) = %d, want %d", len(LogLevels), len(want))
-	}
-	for i := range want {
-		if LogLevels[i] != want[i] {
-			t.Fatalf("LogLevels = %v, want %v", LogLevels, want)
-		}
-	}
-}
-
-// allLevels — набор «отмечены все уровни» (состояние фильтра по умолчанию).
-func allLevels() map[string]bool {
-	m := make(map[string]bool, len(LogLevels))
-	for _, lvl := range LogLevels {
-		m[lvl] = true
-	}
-	return m
-}
-
-// По умолчанию (все уровни отмечены) рендерится полный лог; уровни
-// нормализуются при добавлении.
-func TestLogBufferRenderAllByDefault(t *testing.T) {
-	b := NewLogBuffer(1000)
-	b.Append("error", "e1")
-	b.Append("warn", "w1")  // синоним → warning
-	b.Append("log", "i1")   // неизвестный уровень → info
-	b.Append("trace", "d1") // синоним → debug
-
-	got := b.Render(allLevels())
-	want := "e1\nw1\ni1\nd1\n"
-	if got != want {
-		t.Fatalf("Render(all) = %q, want %q", got, want)
-	}
-
-	entries := b.Entries()
-	wantLvls := []string{LogLevelError, LogLevelWarning, LogLevelInfo, LogLevelDebug}
-	for i, e := range entries {
-		if e.Level != wantLvls[i] {
-			t.Fatalf("entry[%d].Level = %q, want %q", i, e.Level, wantLvls[i])
-		}
-	}
-}
-
-// Показываются только записи выбранных уровней.
-func TestLogBufferRenderSelectedOnly(t *testing.T) {
-	b := NewLogBuffer(1000)
-	b.Append(LogLevelError, "err line")
-	b.Append(LogLevelWarning, "warn line")
-	b.Append(LogLevelInfo, "info line")
-	b.Append(LogLevelDebug, "debug line")
-
-	onlyErrors := map[string]bool{LogLevelError: true}
-	if got, want := b.Render(onlyErrors), "err line\n"; got != want {
-		t.Fatalf("Render(error only) = %q, want %q", got, want)
-	}
-
-	errorsAndDebug := map[string]bool{LogLevelError: true, LogLevelDebug: true}
-	if got, want := b.Render(errorsAndDebug), "err line\ndebug line\n"; got != want {
-		t.Fatalf("Render(error+debug) = %q, want %q", got, want)
-	}
-}
-
-// Ни один уровень не выбран — лента пуста (и это не ошибка).
-func TestLogBufferRenderEmptySelection(t *testing.T) {
-	b := NewLogBuffer(1000)
-	b.Append(LogLevelError, "err line")
-	b.Append(LogLevelInfo, "info line")
-
-	if got := b.Render(map[string]bool{}); got != "" {
-		t.Fatalf("Render(none) = %q, want empty", got)
-	}
-	if got := b.Render(nil); got != "" {
-		t.Fatalf("Render(nil) = %q, want empty", got)
-	}
-}
-
-// Фильтрация применяется и к уже загруженным записям: смена набора уровней
-// меняет результат рендера того же буфера без новых Append.
-func TestLogBufferRefilterLoadedEntries(t *testing.T) {
-	b := NewLogBuffer(1000)
-	b.Append(LogLevelError, "err line")
-	b.Append(LogLevelInfo, "info line")
-
-	all := allLevels()
-	if got, want := b.Render(all), "err line\ninfo line\n"; got != want {
-		t.Fatalf("Render(all) = %q, want %q", got, want)
-	}
-	delete(all, LogLevelInfo)
-	if got, want := b.Render(all), "err line\n"; got != want {
-		t.Fatalf("Render(error) after refilter = %q, want %q", got, want)
-	}
-	all[LogLevelInfo] = true // вернули галочку — запись снова видима
-	if got, want := b.Render(all), "err line\ninfo line\n"; got != want {
-		t.Fatalf("Render(all) after re-check = %q, want %q", got, want)
-	}
-}
-
-// Новые записи сразу попадают в ленту своего уровня.
-func TestLogBufferNewEntriesVisibleImmediately(t *testing.T) {
-	b := NewLogBuffer(1000)
-	sel := map[string]bool{LogLevelError: true}
-
-	b.Append(LogLevelError, "first")
-	if got, want := b.Render(sel), "first\n"; got != want {
-		t.Fatalf("Render = %q, want %q", got, want)
-	}
-
-	b.Append(LogLevelInfo, "noise") // невидимый уровень — ленту не меняет
-	if got, want := b.Render(sel), "first\n"; got != want {
-		t.Fatalf("Render after invisible append = %q, want %q", got, want)
-	}
-
-	b.Append(LogLevelError, "second")
-	if got, want := b.Render(sel), "first\nsecond\n"; got != want {
-		t.Fatalf("Render after visible append = %q, want %q", got, want)
-	}
-}
-
-// Буфер ограничен: старые записи вытесняются, суммарный объём ≤ лимита.
-func TestLogBufferBounded(t *testing.T) {
-	b := NewLogBuffer(10)
-	for i := 0; i < 5; i++ {
-		b.Append(LogLevelInfo, "0123456789") // каждая запись — ровно лимит
-	}
-	entries := b.Entries()
-	if len(entries) != 1 {
-		t.Fatalf("len(entries) = %d, want 1 (старые вытеснены)", len(entries))
-	}
-	if entries[0].Text != "0123456789" {
-		t.Fatalf("text = %q", entries[0].Text)
-	}
-
-	// одиночная запись длиннее лимита обрезается до последних maxLen символов
-	b2 := NewLogBuffer(4)
-	b2.Append(LogLevelInfo, "abcdefgh")
-	if got := b2.Entries()[0].Text; got != "efgh" {
-		t.Fatalf("oversized entry text = %q, want %q", got, "efgh")
-	}
-}
-
-// Буфер держит только живые записи: ленивое вытеснение (start) не даёт
-// «мёртвым» записям попасть в Entries/Render.
-func TestLogBufferLiveEntriesOnly(t *testing.T) {
-	b := NewLogBuffer(30)
-	for i := 0; i < 3; i++ {
-		b.Append(LogLevelInfo, "0123456789") // 10 байт + \n каждая
-	}
-	// сумма 33 > 30 → вытесняется первая запись, остаются две живые
-	entries := b.Entries()
-	if len(entries) != 2 {
-		t.Fatalf("len(Entries) = %d, want 2 (мёртвая запись скрыта)", len(entries))
-	}
-	if entries[0].Text != "0123456789" || entries[1].Text != "0123456789" {
-		t.Fatalf("unexpected live entries: %+v", entries)
-	}
-	if got, want := b.Render(allLevels()), "0123456789\n0123456789\n"; got != want {
-		t.Fatalf("Render = %q, want %q", got, want)
-	}
-}
-
-// Кап считается по байтам текста, а не по числу записей: короткие записи
-// не вытесняются, пока их суммарный объём не превысит лимит.
-func TestLogBufferBytesCap(t *testing.T) {
-	b := NewLogBuffer(100)
-	for i := 0; i < 3; i++ {
-		b.Append(LogLevelInfo, "hello") // 5 байт + \n
-	}
-	if got := len(b.Entries()); got != 3 {
-		t.Fatalf("len(Entries) = %d, want 3 (все помещаются)", got)
-	}
-
-	// одна большая запись вытесняет всё старое (live=1) и обрезается
-	b2 := NewLogBuffer(8)
-	b2.Append(LogLevelInfo, "short")
-	b2.Append(LogLevelInfo, "verylongtext")
-	entries := b2.Entries()
-	if len(entries) != 1 {
-		t.Fatalf("len(Entries) = %d, want 1", len(entries))
-	}
-	if entries[0].Text != "longtext" {
-		t.Fatalf("oversized entry text = %q, want %q", entries[0].Text, "longtext")
-	}
-}
-
-// Первый RenderNew отдаёт весь видимый текст, последующие — только новые
-// записи (инкрементальная отрисовка: повторный вызов без Append пуст).
-func TestLogBufferRenderNewDelta(t *testing.T) {
-	b := NewLogBuffer(1000)
-	sel := allLevels()
-
-	b.Append(LogLevelError, "e1")
-	b.Append(LogLevelInfo, "i1")
-	text, full := b.RenderNew(sel)
-	if full {
-		t.Fatalf("первый RenderNew не должен требовать полного пересбора, got full")
-	}
-	if text != "e1\ni1\n" {
-		t.Fatalf("первый RenderNew = %q, want %q", text, "e1\ni1\n")
-	}
-
-	// Без новых записей — пустой дельта.
-	text, full = b.RenderNew(sel)
-	if full || text != "" {
-		t.Fatalf("повторный RenderNew без новых записей = (%q, %v), want (\"\", false)", text, full)
-	}
-
-	// Новые записи — только их текст, без повторной отдачи старых.
-	b.Append(LogLevelInfo, "i2")
-	text, _ = b.RenderNew(sel)
-	if text != "i2\n" {
-		t.Fatalf("дельта RenderNew = %q, want %q", text, "i2\n")
-	}
-}
-
-// RenderNew применяет фильтр: невидимые уровни не попадают в дельту.
-func TestLogBufferRenderNewFiltered(t *testing.T) {
-	b := NewLogBuffer(1000)
-	sel := map[string]bool{LogLevelError: true}
-	b.Append(LogLevelError, "e1")
-	b.Append(LogLevelInfo, "i1")
-	b.Append(LogLevelError, "e2")
-
-	text, _ := b.RenderNew(sel)
-	if text != "e1\ne2\n" {
-		t.Fatalf("RenderNew(error only) = %q, want %q", text, "e1\ne2\n")
-	}
-}
-
-// RenderNew уважает ResetRendered: после полного рендера новые записи
-// добавляются дельтом, а не вытесняют уже выведенный текст.
-func TestLogBufferRenderNewAfterReset(t *testing.T) {
-	b := NewLogBuffer(1000)
-	sel := allLevels()
-	b.Append(LogLevelInfo, "old")
-	b.Append(LogLevelInfo, "base")
-
-	text, full := b.RenderNew(sel)
-	if full || text != "old\nbase\n" {
-		t.Fatalf("RenderNew = (%q, %v), want (\"old\\nbase\\n\", false)", text, full)
-	}
-	b.ResetRendered() // имитация полной пересборки ленты
-
-	b.Append(LogLevelInfo, "new")
-	text, full = b.RenderNew(sel)
-	if full || text != "new\n" {
-		t.Fatalf("RenderNew после Reset = (%q, %v), want (\"new\\n\", false)", text, full)
-	}
-}
-
-// Вытеснение уже выведенных записей помечает рендер как требующий полного
-// пересбора (stale): дельта не может убрать верхние строки.
-func TestLogBufferRenderNewEvictionStale(t *testing.T) {
-	b := NewLogBuffer(25) // записи по 10 байт + \n: помещаются 2, 3-я вытесняет 1-ю
-	sel := allLevels()
-
-	b.Append(LogLevelInfo, "0123456789")
-	b.Append(LogLevelInfo, "0123456789")
-	text, full := b.RenderNew(sel)
-	if full || text != "0123456789\n0123456789\n" {
-		t.Fatalf("RenderNew = (%q, %v), want two lines", text, full)
-	}
-
-	// Третья запись вытесняет первую (уже отрисованную) — stale.
-	b.Append(LogLevelInfo, "0123456789")
-	text, full = b.RenderNew(sel)
-	if !full {
-		t.Fatalf("RenderNew после вытеснения = (full=%v), want full=true", full)
-	}
-	if text != "0123456789\n0123456789\n" {
-		t.Fatalf("полный текст после вытеснения = %q, want последние две записи", text)
-	}
-}
--- a/internal/ui/session.go
+++ b/internal/ui/session.go
@@ -1,43 +0,0 @@
-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 }
--- a/internal/ui/session_test.go
+++ b/internal/ui/session_test.go
@@ -1,55 +0,0 @@
-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")
-	}
-}
--- a/internal/ui/state_panel.go
+++ b/internal/ui/state_panel.go
@@ -1,99 +0,0 @@
-package ui
-
-import (
-	"strings"
-
-	"github.com/kamelion/ratatoskr-go/internal/events"
-	"github.com/kamelion/ratatoskr-go/internal/model"
-	"github.com/kamelion/ratatoskr-go/internal/storage"
-)
-
-// StatePanel — панель «Состояние» (спец 12.13): агенты и трейсы выбранной
-// задачи. Снимок (SetText) + live-строки (Append), буфер ограничен.
-type StatePanel interface {
-	// SetText заменяет содержимое снимком трасс.
-	SetText(text string)
-	// Append добавляет live-строку (буфер ограничен).
-	Append(text string)
-}
-
-// NilStatePanel — no-op реализация StatePanel для headless-режима и тестов.
-type NilStatePanel struct{}
-
-// NewNilStatePanel создаёт NilStatePanel.
-func NewNilStatePanel() *NilStatePanel { return &NilStatePanel{} }
-
-func (NilStatePanel) SetText(string) {}
-func (NilStatePanel) Append(string)  {}
-
-// StateText — снимок трасс задачи (pure-функция, спец 12.13).
-func StateText(traces []storage.Trace) string {
-	var b strings.Builder
-	for _, tr := range traces {
-		b.WriteString(strings.ToUpper(tr.Agent) + ": " + string(tr.Status))
-		if tr.SessionID != "" {
-			b.WriteString(" (session " + tr.SessionID + ")")
-		}
-		b.WriteString("\n")
-	}
-	if b.Len() == 0 {
-		b.WriteString("Нет активных агентов.")
-	}
-	return b.String()
-}
-
-// TraceLine — строка добавленного/обновлённого трейса субагента.
-func TraceLine(agent string, status model.TraceStatus) string {
-	return strings.ToUpper(agent) + ": " + string(status)
-}
-
-// ActivityLine — строка смены этапа агента.
-func ActivityLine(agent, stage string) string {
-	return strings.ToUpper(agent) + " → " + stage
-}
-
-// TaskStatusText — строка изменения статуса задачи (бейдж + ID).
-func TaskStatusText(e events.TaskStatusChanged) string {
-	return StatusBadge(e.To) + " #" + Itoa(e.ID) + ": " + string(e.From) + " → " + string(e.To)
-}
-
-// StatusBadge — эмодзи-бейдж статуса задачи.
-func StatusBadge(s model.Status) string {
-	switch s {
-	case model.StatusSuccess:
-		return "✅"
-	case model.StatusFailed, model.StatusAborted:
-		return "❌"
-	case model.StatusRunning, model.StatusCollecting:
-		return "⏳"
-	case model.StatusReady, model.StatusApproved:
-		return "🟡"
-	case model.StatusCancelled:
-		return "🚫"
-	default:
-		return "•"
-	}
-}
-
-// Itoa — int64 в строку без зависимостей.
-func Itoa(v int64) string {
-	if v == 0 {
-		return "0"
-	}
-	neg := v < 0
-	if neg {
-		v = -v
-	}
-	var b [24]byte
-	i := len(b)
-	for v > 0 {
-		i--
-		b[i] = byte('0' + v%10)
-		v /= 10
-	}
-	if neg {
-		i--
-		b[i] = '-'
-	}
-	return string(b[i:])
-}
--- a/internal/ui/state_panel_test.go
+++ b/internal/ui/state_panel_test.go
@@ -1,50 +0,0 @@
-package ui
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/kamelion/ratatoskr-go/internal/events"
-	"github.com/kamelion/ratatoskr-go/internal/model"
-	"github.com/kamelion/ratatoskr-go/internal/storage"
-)
-
-// StateText — снимок трасс (спец 12.13), pure-функция без Fyne.
-func TestStateText(t *testing.T) {
-	got := StateText(nil)
-	if !strings.Contains(got, "Нет активных агентов.") {
-		t.Errorf("пусто: got %q", got)
-	}
-
-	tr := storage.Trace{Agent: "analyst", Status: model.TraceRunning, SessionID: "s1"}
-	got = StateText([]storage.Trace{tr})
-	if !strings.Contains(got, "ANALYST: running") {
-		t.Errorf("агент/статус не попали: %q", got)
-	}
-	if !strings.Contains(got, "session s1") {
-		t.Errorf("session не попала: %q", got)
-	}
-}
-
-// Live-строки — чистые хелперы.
-func TestStateLines(t *testing.T) {
-	if TraceLine("analyst", model.TraceRunning) != "ANALYST: running" {
-		t.Errorf("TraceLine: %q", TraceLine("analyst", model.TraceRunning))
-	}
-	if ActivityLine("dev", "review") != "DEV → review" {
-		t.Errorf("ActivityLine: %q", ActivityLine("dev", "review"))
-	}
-
-	e := events.TaskStatusChanged{ID: 7, From: model.StatusRunning, To: model.StatusSuccess}
-	got := TaskStatusText(e)
-	if !strings.Contains(got, "✅") || !strings.Contains(got, "#7") {
-		t.Errorf("TaskStatusText: %q", got)
-	}
-}
-
-// NilStatePanel — no-op контракт (спец 12.8): безопасно для headless/тестов.
-func TestNilStatePanelNoop(t *testing.T) {
-	p := NewNilStatePanel()
-	p.SetText("снимок")
-	p.Append("строка")
-}
--- a/internal/ui/task_detail.go
+++ b/internal/ui/task_detail.go
@@ -1,37 +0,0 @@
-package ui
-
-import (
-	"strings"
-
-	"github.com/kamelion/ratatoskr-go/internal/storage"
-)
-
-// TaskDetailPanel — панель «Детали задачи» (спец 12.11): заголовок, статус,
-// детали (цель + репозитории) выбранной задачи.
-//
-// Данные — снимки-копии из Store (спец 12.5). Обновление — на потоке Fyne;
-// вызывающий уже внутри fyne.Do. Диалог и «Состояние» — отдельные панели.
-type TaskDetailPanel interface {
-	// ShowTask рендерит детали из снимка задачи.
-	ShowTask(t storage.Task)
-	// ShowEmpty сбрасывает к placeholder («—» / пусто) при недоступной задаче.
-	ShowEmpty()
-}
-
-// NilTaskDetailPanel — no-op реализация TaskDetailPanel для headless-режима и тестов.
-type NilTaskDetailPanel struct{}
-
-// NewNilTaskDetailPanel создаёт NilTaskDetailPanel.
-func NewNilTaskDetailPanel() *NilTaskDetailPanel { return &NilTaskDetailPanel{} }
-
-func (NilTaskDetailPanel) ShowTask(storage.Task) {}
-func (NilTaskDetailPanel) ShowEmpty()           {}
-
-// TaskDetailText — строка деталей задачи (pure-функция, спец 12.11).
-func TaskDetailText(t storage.Task) string {
-	detail := "Цель: " + t.Goal
-	if len(t.Repos) > 0 {
-		detail += "\nРепозитории: " + strings.Join(t.Repos, ", ")
-	}
-	return detail
-}
--- a/internal/ui/task_detail_test.go
+++ b/internal/ui/task_detail_test.go
@@ -1,36 +0,0 @@
-package ui
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/kamelion/ratatoskr-go/internal/storage"
-)
-
-// TaskDetailText — строка деталей задачи (спец 12.11), pure-функция без Fyne.
-func TestTaskDetailText(t *testing.T) {
-	noRepos := storage.Task{Goal: "Понять код"}
-	got := TaskDetailText(noRepos)
-	if got != "Цель: Понять код" {
-		t.Errorf("без repos: got %q", got)
-	}
-	if strings.Contains(got, "Репозитории") {
-		t.Errorf("без repos не должно быть репозиториев: %q", got)
-	}
-
-	withRepos := storage.Task{Goal: "Рефакторинг", Repos: []string{"a", "b"}}
-	got = TaskDetailText(withRepos)
-	if !strings.Contains(got, "Цель: Рефакторинг") {
-		t.Errorf("цель не попала: %q", got)
-	}
-	if !strings.Contains(got, "Репозитории: a, b") {
-		t.Errorf("репозитории не попали: %q", got)
-	}
-}
-
-// NilTaskDetailPanel — no-op контракт (спец 12.8): безопасно для headless/тестов.
-func TestNilTaskDetailPanelNoop(t *testing.T) {
-	p := NewNilTaskDetailPanel()
-	p.ShowTask(storage.Task{ID: 1, Goal: "x"})
-	p.ShowEmpty()
-}
--- a/internal/ui/task_list_panel.go
+++ b/internal/ui/task_list_panel.go
@@ -1,40 +0,0 @@
-package ui
-
-import (
-	"github.com/kamelion/ratatoskr-go/internal/storage"
-)
-
-// TaskListPanel — панель «Список задач» (спец 12.10): все задачи строками.
-//
-// Данные — снимки-копии из Store (спец 12.5), заменяются через SetTasks.
-// Состояние выбора живёт в окне: окно зовёт Select, чтобы подсветить строку.
-// Контейнер виджета отдаётся окну — реализация (Fyne) сама владеет виджетом.
-type TaskListPanel interface {
-	// SetTasks заменяет снимок списка и перерисовывает виджет.
-	SetTasks(tasks []storage.Task)
-	// Select подсвечивает строку задачи id (управляется окном).
-	Select(id int64)
-	// OnSelect регистрирует колбэк клика по строке (окно грузит детали).
-	OnSelect(fn func(id int64))
-}
-
-// NilTaskListPanel — no-op реализация TaskListPanel для headless-режима и тестов.
-type NilTaskListPanel struct {
-	onSelect func(id int64)
-}
-
-// NewNilTaskListPanel создаёт NilTaskListPanel.
-func NewNilTaskListPanel() *NilTaskListPanel { return &NilTaskListPanel{} }
-
-func (p *NilTaskListPanel) SetTasks([]storage.Task) {}
-func (p *NilTaskListPanel) Select(int64)            {}
-func (p *NilTaskListPanel) OnSelect(fn func(int64)) { p.onSelect = fn }
-
-// TaskTitle — строка задачи в списке (pure-функция, спец 12.10).
-func TaskTitle(t storage.Task) string {
-	title := t.Title
-	if title == "" {
-		title = "(без названия)"
-	}
-	return title + "\n" + string(t.Status)
-}
--- a/internal/ui/task_list_panel_test.go
+++ b/internal/ui/task_list_panel_test.go
@@ -1,40 +0,0 @@
-package ui
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/kamelion/ratatoskr-go/internal/storage"
-)
-
-// TaskTitle — строка в списке задач (спец 12.10), pure-функция без Fyne.
-func TestTaskTitle(t *testing.T) {
-	empty := storage.Task{Status: storage.StatusReady}
-	got := TaskTitle(empty)
-	if !strings.Contains(got, "(без названия)") {
-		t.Errorf("пустое название: got %q, want «(без названия)»", got)
-	}
-	if !strings.Contains(got, string(storage.StatusReady)) {
-		t.Errorf("строка должна содержать статус, got %q", got)
-	}
-
-	named := storage.Task{Title: "Тест", Status: storage.StatusRunning}
-	got = TaskTitle(named)
-	if !strings.Contains(got, "Тест") {
-		t.Errorf("название не попало в строку: %q", got)
-	}
-	if !strings.Contains(got, string(storage.StatusRunning)) {
-		t.Errorf("статус не попал в строку: %q", got)
-	}
-}
-
-// NilTaskListPanel — no-op контракт (спец 12.8): безопасно для headless/тестов.
-func TestNilTaskListPanelNoop(t *testing.T) {
-	p := NewNilTaskListPanel()
-	p.SetTasks([]storage.Task{{ID: 1}})
-	p.Select(1)
-
-	var got []int64
-	p.OnSelect(func(id int64) { got = append(got, id) })
-	// Nil не вызывает колбэки — нет виджета, но вызовы безопасны.
-}
--- a/internal/update/update.go
+++ b/internal/update/update.go
@@ -31,9 +31,7 @@ import (
 	"os/exec"
 	"path/filepath"
 	"runtime"
-	"sort"
 	"strings"
-	"sync"
 	"time"
 )

@@ -52,11 +50,6 @@ type Updater struct {
 	// Dir — каталог рядом с бинарём (для .new/.old и companion-метаданных).
 	// Ставится app из os.Executable(); если пуст — используется каталог Workdir.
 	Dir string
-
-	// client — общий HTTP-клиент (keep-alive), чтобы проверки/скачивания
-	// переиспользовали соединения, а не создавали новое на каждый запрос.
-	client   *http.Client
-	clientMu sync.Mutex
 }

 // Result — результат Check.
@@ -125,26 +118,16 @@ func (u *Updater) versionsURL() string {
 	return base + "/api/v1/packages/" + url.PathEscape(u.Owner) + "/generic/" + url.PathEscape(u.Package)
 }

-// httpClient возвращает общий клиент (keep-alive), инициализируя лениво.
-func (u *Updater) httpClient() *http.Client {
-	u.clientMu.Lock()
-	defer u.clientMu.Unlock()
-	if u.client == nil {
-		u.client = &http.Client{Timeout: 30 * time.Second}
-	}
-	return u.client
-}
-
 // httpGet скачивает файл по URL бэкенда. При Token непустом — Basic/токен-заголовок.
-func (u *Updater) httpGet(ctx context.Context, url string) ([]byte, error) {
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+func (u *Updater) httpGet(url string) ([]byte, error) {
+	req, err := http.NewRequest(http.MethodGet, url, nil)
 	if err != nil {
 		return nil, err
 	}
 	if u.Token != "" {
 		req.Header.Set("Authorization", "token "+u.Token)
 	}
-	resp, err := u.httpClient().Do(req)
+	resp, err := (&http.Client{Timeout: 30 * time.Second}).Do(req)
 	if err != nil {
 		return nil, err
 	}
@@ -155,61 +138,6 @@ func (u *Updater) httpGet(ctx context.Context, url string) ([]byte, error) {
 	return io.ReadAll(resp.Body)
 }

-// fileExists проверяет наличие файла по URL без скачивания тела: HEAD,
-// а при 405/501 (сервер не поддерживает HEAD) — fallback на GET с Range байт 0-0.
-// Возвращает (false, nil) при 404/410 — файла нет.
-func (u *Updater) fileExists(ctx context.Context, url string) (bool, error) {
-	req, err := http.NewRequestWithContext(ctx, http.MethodHead, url, nil)
-	if err != nil {
-		return false, err
-	}
-	if u.Token != "" {
-		req.Header.Set("Authorization", "token "+u.Token)
-	}
-	resp, err := u.httpClient().Do(req)
-	if err != nil {
-		return false, err
-	}
-	resp.Body.Close()
-	switch {
-	case resp.StatusCode == http.StatusNotFound || resp.StatusCode == http.StatusGone:
-		return false, nil
-	case resp.StatusCode == http.StatusOK || resp.StatusCode == http.StatusPartialContent:
-		return true, nil
-	case resp.StatusCode == http.StatusMethodNotAllowed || resp.StatusCode == http.StatusNotImplemented:
-		// Gitea может не отвечать на HEAD — проверяем GET с Range 0-0 без чтения тела.
-		return u.fileExistsByRange(ctx, url)
-	default:
-		return false, nil
-	}
-}
-
-// fileExistsByRange проверяет наличие файла GET'ом с Range: bytes=0-0.
-// Тело не читается: достаточно лишь первых байт заголовков ответа.
-func (u *Updater) fileExistsByRange(ctx context.Context, url string) (bool, error) {
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
-	if err != nil {
-		return false, err
-	}
-	if u.Token != "" {
-		req.Header.Set("Authorization", "token "+u.Token)
-	}
-	req.Header.Set("Range", "bytes=0-0")
-	resp, err := u.httpClient().Do(req)
-	if err != nil {
-		return false, err
-	}
-	resp.Body.Close()
-	switch {
-	case resp.StatusCode == http.StatusNotFound || resp.StatusCode == http.StatusGone:
-		return false, nil
-	case resp.StatusCode == http.StatusOK || resp.StatusCode == http.StatusPartialContent:
-		return true, nil
-	default:
-		return false, nil
-	}
-}
-
 // Check определяет, есть ли более свежая версия в Gitea Packages.
 // Не скачивает бинарь. Ошибка (U1) возвращается в Result.Err — вызывающий
 // решает, логировать и пропустить.
@@ -239,12 +167,8 @@ type pkgVersion struct {
 // ResolveLatest определяет идентификатор новейшей применимой версии пакета.
 // Бинарь/метаданные читаем из КОНКРЕТНОЙ версии, а не из pseudo-`latest`,
 // чтобы companion-файлы и бинарь всегда брались из одного снимка.
-//
-// Применимость версии проверяем НАЛИЧИЕМ бинаря платформы (HEAD без тела),
-// а не скачиванием полного файла: при N версиях это N запросов заголовков
-// вместо N×(размер бинаря) байт.
 func (u *Updater) ResolveLatest(ctx context.Context) (string, error) {
-	b, err := u.httpGet(ctx, u.versionsURL())
+	b, err := u.httpGet(u.versionsURL())
 	if err != nil {
 		return "", err
 	}
@@ -252,28 +176,30 @@ func (u *Updater) ResolveLatest(ctx context.Context) (string, error) {
 	if err := json.Unmarshal(b, &vers); err != nil {
 		return "", ue(U1, "list "+u.versionsURL(), err)
 	}
-	// новые версии — с большим ID; идём с новейшей и берём первую с бинарём.
-	sort.SliceStable(vers, func(i, j int) bool { return vers[i].ID > vers[j].ID })
 	want := PlatformFilename()
+	// выбираем самую свежую версию (макс. id) класса commit-*, в которой есть бинарь.
+	best := ""
+	var bestID int64
 	for _, v := range vers {
 		if !strings.HasPrefix(v.Ver, "commit-") {
 			continue
 		}
-		exists, ferr := u.fileExists(ctx, u.fileURL(v.Ver, want))
-		if ferr != nil {
-			continue // сетевые ошибки пробы не роняют проверку
+		// версия применима, только если в ней опубликован бинарь нашей платформы
+		if _, err := u.httpGet(u.fileURL(v.Ver, want)); err != nil {
+			continue
 		}
-		if exists {
-			return v.Ver, nil
+		if v.ID > bestID {
+			bestID = v.ID
+			best = v.Ver
 		}
 	}
-	return "", nil
+	return best, nil
 }

 // Download скачивает бинарь конкретной версии во временный файл и возвращает
 // путь к нему. Файл: <Dir>/.ratatoskr.<ver>.new.
 func (u *Updater) Download(ctx context.Context, version string) (string, error) {
-	b, err := u.httpGet(ctx, u.fileURL(version, PlatformFilename()))
+	b, err := u.httpGet(u.fileURL(version, PlatformFilename()))
 	if err != nil {
 		return "", err // уже U3
 	}
@@ -290,7 +216,7 @@ func (u *Updater) Download(ctx context.Context, version string) (string, error)

 // versionSum256 читает companion-файл контрольной суммы конкретной версии.
 func (u *Updater) versionSum256(ctx context.Context, version string) (string, error) {
-	b, err := u.httpGet(ctx, u.fileURL(version, PlatformFilename()+".sha256"))
+	b, err := u.httpGet(u.fileURL(version, PlatformFilename()+".sha256"))
 	if err != nil {
 		return "", err
 	}
--- a/internal/update/update_test.go
+++ b/internal/update/update_test.go
@@ -9,7 +9,6 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
-	"sync/atomic"
 	"testing"
 )

@@ -42,7 +41,7 @@ func mockGitea(t *testing.T, bin []byte, version, checksum string) *httptest.Ser
 		_ = json.NewEncoder(w).Encode(versions)
 	})
 	mux.HandleFunc("/api/packages/", func(w http.ResponseWriter, r *http.Request) {
-		if r.Method != http.MethodGet && r.Method != http.MethodHead {
+		if r.Method != http.MethodGet {
 			http.Error(w, "method", http.StatusMethodNotAllowed)
 			return
 		}
@@ -59,10 +58,7 @@ func mockGitea(t *testing.T, bin []byte, version, checksum string) *httptest.Ser
 			http.NotFound(w, r)
 			return
 		}
-		if r.Method == http.MethodGet {
 		_, _ = w.Write(body)
-		}
-		// HEAD — просто 200, тело не пишем
 	})
 	return httptest.NewServer(mux)
 }
@@ -137,104 +133,6 @@ func TestCheck_ServerDown(t *testing.T) {
 	}
 }

-// TestResolveLatest_HeadNotFullDownload проверяет, что ResolveLatest проверяет
-// наличие бинаря HEAD'ом и НЕ скачивает полное тело бинаря (прошлая версия
-// читала каждый файл целиком — O(N)×размер бинаря).
-func TestResolveLatest_HeadNotFullDownload(t *testing.T) {
-	name := PlatformFilename()
-	_ = name
-	var headReqs, bodyReqs int64
-	mux := http.NewServeMux()
-	mux.HandleFunc("/api/v1/packages/", func(w http.ResponseWriter, _ *http.Request) {
-		_ = json.NewEncoder(w).Encode([]map[string]any{
-			{"id": 1, "version": "commit-aaa1111"},
-			{"id": 2, "version": "commit-abc1234"},
-		})
-	})
-	mux.HandleFunc("/api/packages/", func(w http.ResponseWriter, r *http.Request) {
-		parts := strings.Split(strings.Trim(r.URL.Path, "/"), "/")
-		if len(parts) < 6 {
-			http.NotFound(w, r)
-			return
-		}
-		ver := parts[len(parts)-2]
-		fileName := parts[len(parts)-1]
-		if ver != "commit-abc1234" || fileName != name {
-			http.NotFound(w, r)
-			return
-		}
-		switch r.Method {
-		case http.MethodHead:
-			atomic.AddInt64(&headReqs, 1)
-		case http.MethodGet:
-			atomic.AddInt64(&bodyReqs, 1)
-		default:
-			http.Error(w, "method", http.StatusMethodNotAllowed)
-		}
-	})
-	srv := httptest.NewServer(mux)
-	defer srv.Close()
-
-	u := &Updater{BaseURL: srv.URL, Owner: "k", Package: "p", CurrentVersion: "v1", Dir: t.TempDir()}
-	ver, err := u.ResolveLatest(context.Background())
-	if err != nil {
-		t.Fatalf("ResolveLatest err = %v", err)
-	}
-	if ver != "commit-abc1234" {
-		t.Errorf("ResolveLatest = %q, want commit-abc1234", ver)
-	}
-	if atomic.LoadInt64(&headReqs) == 0 {
-		t.Error("ResolveLatest не делал HEAD-проб на файлы")
-	}
-	if atomic.LoadInt64(&bodyReqs) != 0 {
-		t.Errorf("ResolveLatest скачал тело бинарника: %d полных GET", atomic.LoadInt64(&bodyReqs))
-	}
-}
-
-// TestResolveLatest_SkipsBinarylessVersion проверяет фоллбэк: новейшая версия
-// без бинаря (разные матрицы платформ публикуются не все сразу) пропускается,
-// берётся следующая, где файл есть.
-func TestResolveLatest_SkipsBinarylessVersion(t *testing.T) {
-	name := PlatformFilename()
-	bin := []byte("binary")
-	mux := http.NewServeMux()
-	mux.HandleFunc("/api/v1/packages/", func(w http.ResponseWriter, _ *http.Request) {
-		_ = json.NewEncoder(w).Encode([]map[string]any{
-			{"id": 1, "version": "commit-aaa1111"},
-			{"id": 2, "version": "commit-mid2222"},
-			{"id": 3, "version": "commit-new3333"},
-		})
-	})
-	mux.HandleFunc("/api/packages/", func(w http.ResponseWriter, r *http.Request) {
-		parts := strings.Split(strings.Trim(r.URL.Path, "/"), "/")
-		if len(parts) < 6 {
-			http.NotFound(w, r)
-			return
-		}
-		ver := parts[len(parts)-2]
-		fileName := parts[len(parts)-1]
-		// бинарь есть только у commit-mid2222 — новейшие 1 и 3 пропускаются
-		if ver != "commit-mid2222" || fileName != name {
-			http.NotFound(w, r)
-			return
-		}
-		if r.Method != http.MethodHead {
-			_, _ = w.Write(bin)
-		}
-	})
-	srv := httptest.NewServer(mux)
-	defer srv.Close()
-
-	u := &Updater{BaseURL: srv.URL, Owner: "k", Package: "p", CurrentVersion: "v0", Dir: t.TempDir()}
-	ver, err := u.ResolveLatest(context.Background())
-	if err != nil {
-		t.Fatalf("ResolveLatest err = %v", err)
-	}
-	if ver != "commit-mid2222" {
-		t.Errorf("ResolveLatest = %q, want commit-mid2222 (фоллбэк от версии без бинаря)", ver)
-	}
-}
-
 func TestDownload_And_Verify_Good(t *testing.T) {
 	bin := []byte("ratatoskr-binary-content-v2")
 	u, dir := testUpdater(t, bin, "commit-new12345", "")
--- a/internal/worker/postmortem.go
+++ b/internal/worker/postmortem.go
@@ -1,242 +0,0 @@
-package worker
-
-import (
-	"context"
-	"fmt"
-	"log"
-	"strings"
-	"text/template"
-
-	"github.com/kamelion/ratatoskr-go/internal/events"
-	"github.com/kamelion/ratatoskr-go/internal/storage"
-)
-
-// postMortemAgent — имя постмортем-агента (файл agents/postmortem.md).
-const postMortemAgent = "postmortem"
-
-// traceOutputMax — обрезка вывода сессии в постмортем-промпте (чтобы промпт
-// не превращался в полные транскрипты и не переполнял контекст модели).
-const traceOutputMax = 6000
-
-// sessionTranscriptMax — обрезка транскрипта сессии dev/reviewer в промпте.
-const sessionTranscriptMax = 20000
-
-// postMortemPromptTemplate — промпт для постмортем-агента после failed/timeout:
-// задача + сессии dev/reviewer. Ожидается резюме простым текстом на русском.
-var postMortemPromptTemplate = template.Must(template.New("postmortem").Parse(`Ты — постмортем-аналитик в конвейере Ratatoskr. Задача завершилась неудачей ({{.Status}}). Проанализируй сессии агентов dev/reviewer и дай резюме: почему так случилось и что сделать, чтобы не повторялось.
-
-**Задача:**
-{{if .Title}}Название: {{.Title}}{{end}}
-{{if .Goal}}Цель: {{.Goal}}{{end}}
-{{if .Repos}}
-Репозитории:
-{{- range .Repos}}
-  - {{.}}
-{{- end}}
-{{end}}
-{{if .Why}}Зачем: {{.Why}}{{end}}
-{{if .AC}}Критерии готовности (AC):
-{{.AC}}{{end}}
-
-**Итоговый статус задачи:** {{.Status}}
-
-**Сессии субагентов:**
-{{.Sessions}}
-
-Ответь ПРОСТЫМ ТЕКСТОМ на русском, без JSON и разметки. Формат:
-
-Почему так случилось:
- <причина 1>
- <причина 2>
-
-Что сделать, чтобы это не повторялось:
- <рекомендация 1>
- <рекомендация 2>`))
-
-// PostMortemPromptData — данные для рендера постмортем-промпта.
-type PostMortemPromptData struct {
-	Title    string
-	Goal     string
-	Repos    []string
-	Why      string
-	AC       string
-	Status   storage.Status
-	Sessions string
-}
-
-// RenderPostMortemPrompt собирает промпт для постмортем-агента.
-func RenderPostMortemPrompt(data PostMortemPromptData) (string, error) {
-	var buf strings.Builder
-	if err := postMortemPromptTemplate.Execute(&buf, data); err != nil {
-		return "", err
-	}
-	return buf.String(), nil
-}
-
-// postMortemsText форматирует сессии dev/reviewer в секцию промпта: поля
-// трассы (session_id, промпт, вывод) + транскрипт сессии (шаги агента).
-// transcripts — sessionID → транскрипт (пустая строка — в сессии нет сообщений);
-// отсутствие ключа — транскрипт недоступен (сбой чтения).
-func postMortemsText(traces []storage.Trace, transcripts map[string]string) string {
-	var b strings.Builder
-	for _, tr := range traces {
-		b.WriteString("\n=== Агент: " + tr.Agent + " (статус " + string(tr.Status) + ") ===\n")
-		if tr.SessionID != "" {
-			b.WriteString("session_id: " + tr.SessionID + "\n")
-		}
-		if strings.TrimSpace(tr.Prompt) != "" {
-			b.WriteString("-- Промпт агента --\n")
-			b.WriteString(tr.Prompt)
-			b.WriteString("\n")
-		}
-		if strings.TrimSpace(tr.Output) != "" {
-			b.WriteString("-- Вывод агента --\n")
-			b.WriteString(truncateTrace(tr.Output, traceOutputMax))
-			b.WriteString("\n")
-		}
-		if tr.SessionID != "" {
-			tx, ok := transcripts[tr.SessionID]
-			b.WriteString("-- Транскрипт сессии (шаги агента) --\n")
-			switch {
-			case !ok:
-				b.WriteString("(транскрипт сессии недоступен)\n")
-			case strings.TrimSpace(tx) == "":
-				b.WriteString("(в сессии нет сообщений — агент не сделал ни одного шага)\n")
-			default:
-				b.WriteString(truncateTrace(tx, sessionTranscriptMax))
-				b.WriteString("\n")
-			}
-		}
-	}
-	if b.Len() == 0 {
-		return "(сессии dev/reviewer не найдены — вероятна инфраструктурная ошибка до запуска агентов)"
-	}
-	return b.String()
-}
-
-// truncateTrace обрезает длинный текст до последних n символов (релевантен
-// хвост: вердикт/ошибка агента в конце вывода).
-func truncateTrace(s string, n int) string {
-	if len(s) <= n {
-		return s
-	}
-	if n <= 0 {
-		return ""
-	}
-	return "(вывод обрезан)\n" + s[len(s)-n:]
-}
-
-// hasPostMortemTrace возвращает true, если у задачи уже есть постмортем-trace
-// (защита от повторного запуска при повторных прогонах/retry).
-func (w *Worker) hasPostMortemTrace(ctx context.Context, taskID int64) bool {
-	if w.Store == nil {
-		return false
-	}
-	_, err := w.Store.GetLatestTrace(ctx, taskID, postMortemAgent)
-	return err == nil
-}
-
-// postMortem запускает постмортем-агент для задачи, завершившейся failed/timeout:
-// собирает сессии dev/reviewer из трасс, даёт агенту анализ, сохраняет результат
-// как trace agent=postmortem и уведомляет владельца задачи резюме.
-//
-// Статус задачи НЕ меняется (failed/timeout остаётся достигнутым); собственные
-// сбои постмортема не влияют на исход задачи — только логируются.
-func (w *Worker) postMortem(ctx context.Context, task *storage.Task) {
-	if w.Store == nil || w.Runner == nil {
-		return
-	}
-	if w.hasPostMortemTrace(ctx, task.ID) {
-		return
-	}
-
-	traces, err := w.Store.GetTraces(ctx, task.ID)
-	if err != nil {
-		log.Printf("worker: task %d: постмортем: трассы: %v", task.ID, err)
-		return
-	}
-	// Анализируем только сессии агентов конвейера (dev/reviewer).
-	var sessions []storage.Trace
-	for _, tr := range traces {
-		if tr.Agent == "dev" || tr.Agent == "reviewer" {
-			sessions = append(sessions, *tr)
-		}
-	}
-
-	// Достаём транскрипты сессий dev/reviewer (по session_id) — реальные шаги
-	// агента (сообщения/tool-вызовы), которые не попадают в трассу (там только
-	// финальный вывод). Сбои чтения не фатальны: промпт соберётся без них.
-	transcripts := make(map[string]string, len(sessions))
-	for i := range sessions {
-		tr := &sessions[i]
-		if tr.SessionID == "" {
-			continue
-		}
-		tx, tErr := w.Runner.SessionMessages(w.runCtx(ctx, task.ID), w.Worktree, tr.SessionID)
-		if tErr != nil {
-			log.Printf("worker: task %d: постмортем: транскрипт %s (%s): %v", task.ID, tr.Agent, tr.SessionID, tErr)
-			continue
-		}
-		transcripts[tr.SessionID] = tx
-	}
-
-	prompt, pErr := RenderPostMortemPrompt(PostMortemPromptData{
-		Title:    task.Title,
-		Goal:     task.Goal,
-		Repos:    task.EffectiveRepos(),
-		Why:      task.Why,
-		AC:       task.AC,
-		Status:   task.Status,
-		Sessions: postMortemsText(sessions, transcripts),
-	})
-	if pErr != nil {
-		log.Printf("worker: task %d: постмортем: рендер промпта: %v", task.ID, pErr)
-		return
-	}
-
-	// лог-событие для UI-панели «Состояние».
-	w.publish(events.AgentActivity{TaskID: task.ID, Agent: postMortemAgent, Stage: "postmortem"})
-
-	tr := &storage.Trace{TaskID: task.ID, Agent: postMortemAgent, Prompt: prompt}
-	traceID, aErr := w.Store.AppendTrace(ctx, tr)
-	if aErr != nil {
-		log.Printf("worker: task %d: постмортем: create trace: %v", task.ID, aErr)
-		return
-	}
-
-	res, rErr := w.Runner.Run(w.runCtx(ctx, task.ID), prompt, w.Worktree, postMortemAgent, "")
-	if rErr != nil {
-		log.Printf("worker: task %d: постмортем: запуск: %v", task.ID, rErr)
-		w.finalizeTrace(ctx, traceID, storage.TraceFailed, rErr.Error())
-		return
-	}
-	if res.SessionID != "" {
-		_ = w.Store.UpdateTraceSessionID(ctx, traceID, res.SessionID)
-	}
-
-	output := strings.TrimSpace(res.Stdout)
-	status := storage.TraceSuccess
-	if res.RC != 0 || output == "" {
-		status = storage.TraceFailed
-		if output == "" {
-			output = "(постмортем-агент не вернул текст)"
-		}
-	}
-	log.Printf("worker: task %d: постмортем: %s", task.ID, truncateTrace(output, 2000))
-	w.finalizeTrace(ctx, traceID, status, output)
-
-	if res.RC == 0 && output != "" {
-		text := fmt.Sprintf("Задача #%d: 🔍 анализ (после %s)\n%s", task.ID, task.Status, output)
-		w.notify(ctx, task, text)
-	}
-}
-
-// postMortemAfter — defer-хук из runTask: запускает постмортем, если задача
-// завершилась failed/timeout. Собственные ошибки постмортема не мешают
-// исходному результату задачи (возвращаемый *error только читается).
-func (w *Worker) postMortemAfter(ctx context.Context, task *storage.Task, _ *error) {
-	if task.Status != storage.StatusFailed && task.Status != storage.StatusTimeout {
-		return
-	}
-	w.postMortem(ctx, task)
-}
--- a/internal/worker/prompt.go
+++ b/internal/worker/prompt.go
@@ -3,8 +3,6 @@ package worker
 import (
 	"strings"
 	"text/template"
-
-	"github.com/kamelion/ratatoskr-go/internal/storage"
 )

 // devPromptTemplate — промпт для dev-агента при запуске задачи.
@@ -22,12 +20,6 @@ var devPromptTemplate = template.Must(template.New("dev").Parse(`Ты — dev-а
 {{if .Why}}Зачем: {{.Why}}{{end}}
 {{if .AC}}Критерии готовности:
 {{.AC}}{{end}}
-{{if .Steps}}
-**Этапы (выполняй по порядку, у каждого свой критерий готовности):**
-{{- range .Steps}}
-{{.Title}}{{if .AC}} — готово, когда: {{.AC}}{{end}}
-{{- end}}
-{{end}}

 **Инструкции:**
 1. Рабочий каталог — общий корень, в котором лежат все репозитории по именам.
@@ -46,7 +38,6 @@ type DevPromptData struct {
 	Repos []string
 	Why   string
 	AC    string
-	Steps []storage.Step

 	// ReviewFeedback — замечания ревьюера при повторном прогоне dev
 	// (не пусто → dev должен исправить именно это).
--- a/internal/worker/review.go
+++ b/internal/worker/review.go
@@ -4,7 +4,6 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"log"
 	"path/filepath"
 	"strings"

@@ -97,10 +96,6 @@ func (w *Worker) runReviewer(ctx context.Context, taskID int64, cwd, prompt stri
 	}
 	w.finalizeTrace(ctx, traceID, ts, output)

-	if v != nil {
-		log.Printf("reviewer: вердикт: %s", formatReviewVerdict(v))
-	}
-
 	if v == nil {
 		// Невалидный/пустой вывод или RC!=0: не парсится — сигнал на retry.
 		return nil, output, traceID, nil
@@ -124,35 +119,3 @@ func parseReviewVerdict(out string) (*reviewVerdict, error) {
 	}
 	return &v, nil
 }
-
-// formatReviewVerdict собирает человекочитаемое однострочное описание вердикта
-// ревьюера (без JSON-разметки) для панели «Логи».
-func formatReviewVerdict(v *reviewVerdict) string {
-	var b strings.Builder
-	b.WriteString("passed=")
-	b.WriteString(boolElse(v.Passed, "yes", "no"))
-	if len(v.CriticalIssues) > 0 {
-		b.WriteString(", critical=[")
-		b.WriteString(strings.Join(v.CriticalIssues, " | "))
-		b.WriteString("]")
-	}
-	if len(v.SolidViolations) > 0 {
-		b.WriteString(", solid=[")
-		b.WriteString(strings.Join(v.SolidViolations, " | "))
-		b.WriteString("]")
-	}
-	if len(v.Comments) > 0 {
-		b.WriteString(", comments=[")
-		b.WriteString(strings.Join(v.Comments, " | "))
-		b.WriteString("]")
-	}
-	return b.String()
-}
-
-// boolElse возвращает строку для логического значения (без вызова тернарника).
-func boolElse(cond bool, yes, no string) string {
-	if cond {
-		return yes
-	}
-	return no
-}
--- a/internal/worker/worker.go
+++ b/internal/worker/worker.go
@@ -18,9 +18,6 @@ import (
 // OpenCodeRunner — интерфейс для opencode (подменяемый в тестах).
 type OpenCodeRunner interface {
 	Run(ctx context.Context, prompt, cwd, agent, sessionID string) (*opencode.Result, error)
-	// SessionMessages возвращает транскрипт сессии (шаги агента) по sessionID
-	// для постмортем-анализа. cwd — каталог, где живёт сервер пула сессии.
-	SessionMessages(ctx context.Context, cwd, sessionID string) (string, error)
 }

 // PollTaskFunc — callback для обработки готовой задачи (подменяемый в тестах).
@@ -199,10 +196,6 @@ func (w *Worker) pollAndDispatch(ctx context.Context) error {
 // dev-агент реализует, reviewer строго проверяет весь дифф ветки; при не-проходе
 // dev дорабатывает по комментариям; прошло → push ветки + success.
 func (w *Worker) runTask(ctx context.Context, task *storage.Task) (err error) {
-	// 0. постмортем-анализ: если задача завершилась failed/timeout — после
-	// выхода из runTask (всех путей) запускаем анализ сессий dev/reviewer.
-	defer w.postMortemAfter(ctx, task, &err)
-
 	// 1. проверяем статус
 	if task.Status != storage.StatusApproved {
 		return fmt.Errorf("%w: task %d status=%q", ErrLaunch, task.ID, task.Status)
@@ -255,7 +248,6 @@ func (w *Worker) runTask(ctx context.Context, task *storage.Task) (err error) {
 			Repos:          repos,
 			Why:            task.Why,
 			AC:             task.AC,
-			Steps:          task.Steps,
 			Branch:         branch,
 			ReviewFeedback: reviewFeedbackList(branch, feedback),
 		}
@@ -285,8 +277,6 @@ func (w *Worker) runTask(ctx context.Context, task *storage.Task) (err error) {

 		output := res.Stdout

-		log.Printf("worker: task %d: dev вердикт (хвост): %s", task.ID, truncateTrace(output, 2000))
-
 		// 5b. dev не завершился успешно (RC!=0) → фиксируем без ревью.
 		switch res.RC {
 		case 0:
--- a/internal/worker/worker_test.go
+++ b/internal/worker/worker_test.go
@@ -54,16 +54,6 @@ type mockRunnerWorker struct {
 	// (последний вечный). Позволяет смоделировать fail-then-pass.
 	reviewSequence []*opencode.Result
 	reviewCount    int
-
-	// postMortemResult — результат постмортем-агента; nil → RC:0 с тестовым
-	// резюме. postMortemCount — сколько раз постмортем вызывался.
-	postMortemResult *opencode.Result
-	postMortemCount  int
-
-	// sessionTranscripts — sessionID → транскрипт для постмортем-агента;
-	// sessionMsgsErr — ошибка чтения транскрипта.
-	sessionTranscripts map[string]string
-	sessionMsgsErr     error
 }

 func (m *mockRunnerWorker) Run(_ context.Context, _, _, agent, _ string) (*opencode.Result, error) {
@@ -81,23 +71,9 @@ func (m *mockRunnerWorker) Run(_ context.Context, _, _, agent, _ string) (*openc
 		}
 		return &opencode.Result{RC: 0, Stdout: `{"passed":true,"comments":[]}`}, nil
 	}
-	if agent == postMortemAgent {
-		m.postMortemCount++
-		if m.postMortemResult != nil {
-			return m.postMortemResult, m.err
-		}
-		return &opencode.Result{RC: 0, Stdout: "Почему так случилось:\n- тестовое резюме\nЧто сделать:\n- исправить"}, nil
-	}
 	return m.result, m.err
 }

-func (m *mockRunnerWorker) SessionMessages(_ context.Context, _, sessionID string) (string, error) {
-	if m.sessionMsgsErr != nil {
-		return "", m.sessionMsgsErr
-	}
-	return m.sessionTranscripts[sessionID], nil
-}
-
 // reviewFailedRunner возвращает вердикт not-passed с комментариями.
 func reviewFailedRunner() *opencode.Result {
 	return &opencode.Result{RC: 0, Stdout: `{"passed":false,"critical_issues":[],"solid_violations":["DIP: высокая связанность"],"comments":["исправь связанность"]}`}
@@ -426,17 +402,12 @@ func TestWorkerIterationsLimitNotification(t *testing.T) {
 	if len(texts) == 0 {
 		t.Fatal("нет уведомлений")
 	}
-	// где-то в списке есть уведомление о failed с упоминанием лимита итераций
-	// (над ним — уведомление postmortem, поэтому последним оно не обязано быть).
-	var limitNotif string
-	for _, txt := range texts {
-		if strings.Contains(txt, "failed") && strings.Contains(txt, "итераци") {
-			limitNotif = txt
-			break
+	last := texts[len(texts)-1]
+	if !strings.Contains(last, "failed") {
+		t.Errorf("последнее уведомление = %q, want упоминание failed", last)
 	}
-	}
-	if limitNotif == "" {
-		t.Errorf("нет уведомления о лимите итераций (failed+итераци): %#v", texts)
+	if !strings.Contains(last, "итераци") {
+		t.Errorf("последнее уведомление = %q, want упоминание лимита итераций", last)
 	}
 	// ровно одно уведомление о failed (running→failed не задваивается)
 	var failedCount int
@@ -448,20 +419,9 @@ func TestWorkerIterationsLimitNotification(t *testing.T) {
 	if failedCount != 1 {
 		t.Errorf("уведомлений о failed = %d, want ровно 1: %#v", failedCount, texts)
 	}
-	// есть постмортем-уведомление с анализом
-	var pmCount int
-	for _, txt := range texts {
-		if strings.Contains(txt, "анализ (после failed)") {
-			pmCount++
-		}
-	}
-	if pmCount != 1 {
-		t.Errorf("постмортем-уведомлений = %d, want ровно 1: %#v", pmCount, texts)
-	}
 }

-// TestWorkerTimeoutNotification — RC=-1 (таймаут dev) → уведомление о timeout
-// и постмортем-уведомление с анализом.
+// TestWorkerTimeoutNotification — RC=-1 (таймаут dev) → уведомление о timeout.
 func TestWorkerTimeoutNotification(t *testing.T) {
 	s := setupWorkerDB(t)
 	task := createReadyTask(t, s, "notif-timeout")
@@ -479,21 +439,13 @@ func TestWorkerTimeoutNotification(t *testing.T) {
 	_ = w.runTask(ctx, task)

 	prefix := "Задача #" + strconv.FormatInt(task.ID, 10)
-	texts := notifTexts(n)
-	if len(texts) != 3 {
-		t.Fatalf("уведомлений = %d, want 3: %#v", len(texts), texts)
-	}
 	want := []string{prefix + ": running", prefix + ": timeout"}
-	if !reflect.DeepEqual(texts[:2], want) {
-		t.Errorf("первые уведомления = %#v, want %#v", texts[:2], want)
-	}
-	if !strings.Contains(texts[2], "🔍 анализ (после timeout)") {
-		t.Errorf("постмортем-уведомление = %q, want упоминание «анализ (после timeout)»", texts[2])
+	if got := notifTexts(n); !reflect.DeepEqual(got, want) {
+		t.Errorf("уведомления = %#v, want %#v", got, want)
 	}
 }

-// TestWorkerSpawnErrorNotification — сбой запуска dev → уведомление о failed
-// и постмортем-уведомление.
+// TestWorkerSpawnErrorNotification — сбой запуска dev → уведомление о failed.
 func TestWorkerSpawnErrorNotification(t *testing.T) {
 	s := setupWorkerDB(t)
 	task := createReadyTask(t, s, "notif-spawn")
@@ -511,16 +463,9 @@ func TestWorkerSpawnErrorNotification(t *testing.T) {
 	_ = w.runTask(ctx, task)

 	prefix := "Задача #" + strconv.FormatInt(task.ID, 10)
-	texts := notifTexts(n)
-	if len(texts) != 3 {
-		t.Fatalf("уведомлений = %d, want 3: %#v", len(texts), texts)
-	}
 	want := []string{prefix + ": running", prefix + ": failed"}
-	if !reflect.DeepEqual(texts[:2], want) {
-		t.Errorf("первые уведомления = %#v, want %#v", texts[:2], want)
-	}
-	if !strings.Contains(texts[2], "анализ (после failed)") {
-		t.Errorf("постмортем-уведомление = %q, want упоминание «анализ (после failed)»", texts[2])
+	if got := notifTexts(n); !reflect.DeepEqual(got, want) {
+		t.Errorf("уведомления = %#v, want %#v", got, want)
 	}
 }

@@ -584,10 +529,9 @@ func TestWorkerTimeout(t *testing.T) {
 	s := setupWorkerDB(t)
 	task := createReadyTask(t, s, "slow")

-	runner := &mockRunnerWorker{result: &opencode.Result{RC: -1, Stdout: ""}}
 	w := &Worker{
 		Store:    s,
-		Runner:   runner,
+		Runner:   &mockRunnerWorker{result: &opencode.Result{RC: -1, Stdout: ""}},
 		Worktree: t.TempDir(),
 	}
 	seedFakeRepo(t, w.Worktree, "slow")
@@ -607,20 +551,11 @@ func TestWorkerTimeout(t *testing.T) {
 	if err != nil {
 		t.Fatalf("get traces: %v", err)
 	}
-	if len(traces) != 2 {
-		t.Fatalf("got %d traces, want 2 (dev + postmortem)", len(traces))
+	if len(traces) != 1 {
+		t.Fatalf("got %d traces, want 1", len(traces))
 	}
 	if traces[0].Status != storage.TraceTimeout {
-		t.Errorf("trace[0] status = %q, want timeout", traces[0].Status)
-	}
-	if traces[1].Agent != postMortemAgent {
-		t.Errorf("trace[1] agent = %q, want postmortem", traces[1].Agent)
-	}
-	if traces[1].Status != storage.TraceSuccess {
-		t.Errorf("trace[1] status = %q, want success", traces[1].Status)
-	}
-	if runner.postMortemCount != 1 {
-		t.Errorf("postmortem запускался %d раз, want 1", runner.postMortemCount)
+		t.Errorf("trace status = %q, want timeout", traces[0].Status)
 	}
 }

@@ -628,10 +563,9 @@ func TestWorkerSpawnError(t *testing.T) {
 	s := setupWorkerDB(t)
 	task := createReadyTask(t, s, "spawn-fail")

-	runner := &mockRunnerWorker{err: errors.New("opencode not found")}
 	w := &Worker{
 		Store:    s,
-		Runner:   runner,
+		Runner:   &mockRunnerWorker{err: errors.New("opencode not found")},
 		Worktree: t.TempDir(),
 	}
 	seedFakeRepo(t, w.Worktree, "spawn-fail")
@@ -651,17 +585,11 @@ func TestWorkerSpawnError(t *testing.T) {
 	if err != nil {
 		t.Fatalf("get traces: %v", err)
 	}
-	if len(traces) != 2 {
-		t.Fatalf("got %d traces, want 2 (dev-failed + postmortem)", len(traces))
+	if len(traces) != 1 {
+		t.Fatalf("got %d traces, want 1", len(traces))
 	}
 	if traces[0].Status != storage.TraceFailed {
-		t.Errorf("trace[0] status = %q, want failed", traces[0].Status)
-	}
-	if traces[1].Agent != postMortemAgent {
-		t.Errorf("trace[1] agent = %q, want postmortem", traces[1].Agent)
-	}
-	if runner.postMortemCount != 1 {
-		t.Errorf("postmortem запускался %d раз, want 1", runner.postMortemCount)
+		t.Errorf("trace status = %q, want failed", traces[0].Status)
 	}
 }

@@ -691,8 +619,8 @@ func TestWorkerNonZeroExit(t *testing.T) {
 	if err != nil {
 		t.Fatalf("get traces: %v", err)
 	}
-	if len(traces) != 2 {
-		t.Fatalf("got %d traces, want 2 (dev + postmortem)", len(traces))
+	if len(traces) != 1 {
+		t.Fatalf("got %d traces, want 1", len(traces))
 	}
 	if traces[0].Status != storage.TraceFailed {
 		t.Errorf("trace status = %q, want failed", traces[0].Status)
@@ -700,9 +628,6 @@ func TestWorkerNonZeroExit(t *testing.T) {
 	if traces[0].Output != "error" {
 		t.Errorf("output = %q, want error", traces[0].Output)
 	}
-	if traces[1].Agent != postMortemAgent {
-		t.Errorf("trace[1] agent = %q, want postmortem", traces[1].Agent)
-	}
 }

 func TestWorkerBadStatus(t *testing.T) {
@@ -725,7 +650,6 @@ func TestWorkerBadStatus(t *testing.T) {
 	}
 }

-// TestWorkerPromptRendered — dev-промпт собирается из полей задачи.
 func TestWorkerPromptRendered(t *testing.T) {
 	s := setupWorkerDB(t)
 	task := createReadyTask(t, s, "prompt-test")
@@ -759,63 +683,6 @@ func TestWorkerPromptRendered(t *testing.T) {
 	}
 }

-// TestWorkerPromptIncludesSteps — этапы задачи попадают в dev-промпт по порядку
-// с критериями готовности.
-func TestWorkerPromptIncludesSteps(t *testing.T) {
-	s := setupWorkerDB(t)
-	task := createReadyTask(t, s, "steps-test")
-
-	ctx := context.Background()
-	task.Steps = []storage.Step{
-		{Title: "Модель", AC: "операции готовы"},
-		{Title: "UI"},
-	}
-	if err := s.UpdateTask(ctx, task); err != nil {
-		t.Fatalf("update steps: %v", err)
-	}
-
-	w := &Worker{
-		Store:    s,
-		Runner:   &mockRunnerWorker{result: &opencode.Result{RC: 0, Stdout: "ok", SessionID: "s"}},
-		Worktree: t.TempDir(),
-	}
-	seedFakeRepo(t, w.Worktree, "steps-test")
-
-	_ = w.runTask(ctx, task)
-
-	traces, err := s.GetTraces(ctx, task.ID)
-	if err != nil {
-		t.Fatalf("get traces: %v", err)
-	}
-	tr := traces[0]
-	for _, want := range []string{"Этапы", "Модель", "операции готовы", "UI"} {
-		if !strings.Contains(tr.Prompt, want) {
-			t.Errorf("dev-промпт не содержит %q", want)
-		}
-	}
-}
-
-// TestRenderDevPromptSteps — прямой рендер dev-промпта с этапами.
-func TestRenderDevPromptSteps(t *testing.T) {
-	prompt, err := RenderDevPrompt(DevPromptData{
-		Title: "Калькулятор",
-		AC:    "работает",
-		Steps: []storage.Step{
-			{Title: "Модель", AC: "операции готовы"},
-			{Title: "UI"},
-		},
-		Branch: "feat/abc",
-	})
-	if err != nil {
-		t.Fatalf("render: %v", err)
-	}
-	for _, want := range []string{"Этапы", "Модель — готово, когда: операции готовы", "UI"} {
-		if !strings.Contains(prompt, want) {
-			t.Errorf("prompt не содержит %q", want)
-		}
-	}
-}
-
 func TestFeatureBranchName(t *testing.T) {
 	cases := []struct {
 		tag  string
@@ -1015,267 +882,3 @@ func TestWorkerSemaphore(t *testing.T) {
 		t.Errorf("после освобождения слота success = %d, want 2", len(success))
 	}
 }
-
-// TestWorkerPostMortemSkippedOnSuccess — успешный трейд НЕ запускает постмортем:
-// причина анализа — только failed/timeout.
-func TestWorkerPostMortemSkippedOnSuccess(t *testing.T) {
-	s := setupWorkerDB(t)
-	task := createReadyTask(t, s, "pm-ok")
-
-	runner := &mockRunnerWorker{result: &opencode.Result{RC: 0, Stdout: "done", SessionID: "s"}}
-	w := &Worker{
-		Store:    s,
-		Runner:   runner,
-		Worktree: t.TempDir(),
-	}
-	seedFakeRepo(t, w.Worktree, "pm-ok")
-
-	ctx := context.Background()
-	if err := w.runTask(ctx, task); err != nil {
-		t.Fatalf("runTask: %v", err)
-	}
-	task, _ = s.GetTask(ctx, task.ID)
-	if task.Status != storage.StatusSuccess {
-		t.Fatalf("status = %q, want success", task.Status)
-	}
-	if runner.postMortemCount != 0 {
-		t.Errorf("postmortem запускался %d раз, want 0 при success", runner.postMortemCount)
-	}
-	traces, _ := s.GetTraces(ctx, task.ID)
-	for _, tr := range traces {
-		if tr.Agent == postMortemAgent {
-			t.Errorf("есть неожиданный postmortem-trace при success")
-		}
-	}
-}
-
-// TestWorkerPostMortemFailureDoesNotChangeStatus — сбой самого постмортема не
-// влияет на статус задачи (остаётся failed) и фиксируется как failed-трасса.
-func TestWorkerPostMortemFailureDoesNotChangeStatus(t *testing.T) {
-	s := setupWorkerDB(t)
-	task := createReadyTask(t, s, "pm-fail")
-
-	runner := &mockRunnerWorker{
-		// dev падает при спавне → failed; постмортем тоже падает.
-		err:              errors.New("opencode not found"),
-		postMortemResult: &opencode.Result{RC: 1, Stdout: ""},
-	}
-	w := &Worker{
-		Store:    s,
-		Runner:   runner,
-		Worktree: t.TempDir(),
-	}
-	seedFakeRepo(t, w.Worktree, "pm-fail")
-
-	ctx := context.Background()
-	_ = w.runTask(ctx, task)
-
-	task, _ = s.GetTask(ctx, task.ID)
-	if task.Status != storage.StatusFailed {
-		t.Errorf("status = %q, want failed (постмортем не должен менять статус)", task.Status)
-	}
-	traces, err := s.GetTraces(ctx, task.ID)
-	if err != nil {
-		t.Fatalf("get traces: %v", err)
-	}
-	if len(traces) != 2 {
-		t.Fatalf("traces = %d, want 2 (dev-failed + postmortem)", len(traces))
-	}
-	if traces[1].Agent != postMortemAgent {
-		t.Errorf("trace[1] agent = %q, want postmortem", traces[1].Agent)
-	}
-	if traces[1].Status != storage.TraceFailed {
-		t.Errorf("trace[1] status = %q, want failed (сбой постмортема)", traces[1].Status)
-	}
-}
-
-// TestWorkerPostMortemNotRepeated — если у задачи уже есть postmortem-trace
-// (например, от прошлого прогона), повторный постмортем не запускается.
-func TestWorkerPostMortemNotRepeated(t *testing.T) {
-	s := setupWorkerDB(t)
-	task := createReadyTask(t, s, "pm-repeat")
-
-	ctx := context.Background()
-	if _, err := s.AppendTrace(ctx, &storage.Trace{
-		TaskID: task.ID,
-		Agent:  postMortemAgent,
-		Prompt: "старый анализ",
-		Output: "старое резюме",
-	}); err != nil {
-		t.Fatalf("seed postmortem trace: %v", err)
-	}
-
-	runner := &mockRunnerWorker{err: errors.New("opencode not found")}
-	w := &Worker{
-		Store:    s,
-		Runner:   runner,
-		Worktree: t.TempDir(),
-	}
-	seedFakeRepo(t, w.Worktree, "pm-repeat")
-
-	_ = w.runTask(ctx, task)
-
-	task, _ = s.GetTask(ctx, task.ID)
-	if task.Status != storage.StatusFailed {
-		t.Fatalf("status = %q, want failed", task.Status)
-	}
-	if runner.postMortemCount != 0 {
-		t.Errorf("postmortem запускался %d раз, want 0 (уже был trace)", runner.postMortemCount)
-	}
-	// количество postmortem-трасс не выросло
-	traces, _ := s.GetTraces(ctx, task.ID)
-	var pm int
-	for _, tr := range traces {
-		if tr.Agent == postMortemAgent {
-			pm++
-		}
-	}
-	if pm != 1 {
-		t.Errorf("postmortem-трасс = %d, want 1 (без дубля)", pm)
-	}
-}
-
-// TestWorkerPostMortemUsesTranscript — постмортем достаёт транскрипт dev-сессии
-// (по session_id) и вставляет шаги агента в промпт постмортем-агента.
-func TestWorkerPostMortemUsesTranscript(t *testing.T) {
-	s := setupWorkerDB(t)
-	task := createReadyTask(t, s, "pm-transcript")
-
-	runner := &mockRunnerWorker{
-		result: &opencode.Result{RC: -1, Stdout: "", SessionID: "sess-dev"},
-		sessionTranscripts: map[string]string{
-			"sess-dev": "[Инструмент]\nчитает requirements.md\n[Ассистент]\nправлю main.go",
-		},
-	}
-	w := &Worker{
-		Store:    s,
-		Runner:   runner,
-		Agent:    "dev",
-		Worktree: t.TempDir(),
-	}
-	seedFakeRepo(t, w.Worktree, "pm-transcript")
-
-	ctx := context.Background()
-	_ = w.runTask(ctx, task)
-
-	task, _ = s.GetTask(ctx, task.ID)
-	if task.Status != storage.StatusTimeout {
-		t.Fatalf("status = %q, want timeout", task.Status)
-	}
-
-	traces, err := s.GetTraces(ctx, task.ID)
-	if err != nil {
-		t.Fatalf("get traces: %v", err)
-	}
-	var pm *storage.Trace
-	for _, tr := range traces {
-		if tr.Agent == postMortemAgent {
-			pm = tr
-		}
-	}
-	if pm == nil {
-		t.Fatal("нет постмортем-трассы")
-	}
-	for _, want := range []string{"Транскрипт сессии", "читает requirements.md", "правлю main.go"} {
-		if !strings.Contains(pm.Prompt, want) {
-			t.Errorf("промпт постмортема не содержит %q", want)
-		}
-	}
-}
-
-// TestRenderPostMortemPrompt — промпт постмортема включает задачу, сессии и
-// транскрипт сессий (шаги агентов), а не только финальный вывод.
-func TestRenderPostMortemPrompt(t *testing.T) {
-	tr := storage.Trace{
-		Agent:     "dev",
-		Status:    storage.TraceTimeout,
-		SessionID: "sess-dev-1",
-		Prompt:    "промпт dev",
-		Output:    "вывод dev",
-	}
-	transcripts := map[string]string{
-		"sess-dev-1": "[Инструмент]\nпрочитал файл a.go\n[Ассистент]\nправлю код",
-	}
-	prompt, err := RenderPostMortemPrompt(PostMortemPromptData{
-		Title:    "Таймаут-задача",
-		Goal:     "сделать",
-		Repos:    []string{"calc"},
-		AC:       "работает",
-		Status:   storage.StatusTimeout,
-		Sessions: postMortemsText([]storage.Trace{tr}, transcripts),
-	})
-	if err != nil {
-		t.Fatalf("render: %v", err)
-	}
-	for _, want := range []string{
-		"Таймаут-задача", "timeout", "=== Агент: dev", "промпт dev", "вывод dev",
-		"Транскрипт сессии", "прочитал файл a.go", "правлю код",
-	} {
-		if !strings.Contains(prompt, want) {
-			t.Errorf("промпт не содержит %q", want)
-		}
-	}
-}
-
-// TestPostMortemsTextTranscriptUnavailable — сессия с session_id, для которой
-// транскрипт не загружен, помечается как недоступный, а не падает.
-func TestPostMortemsTextTranscriptUnavailable(t *testing.T) {
-	tr := storage.Trace{Agent: "reviewer", Status: storage.TraceFailed, SessionID: "sess-r"}
-	text := postMortemsText([]storage.Trace{tr}, nil)
-	if !strings.Contains(text, "транскрипт сессии недоступен") {
-		t.Errorf("нет пометки о недоступном транскрипте: %q", text)
-	}
-}
-
-// TestPostMortemsTextTranscriptEmpty — в сессии нет сообщений: агент не сделал
-// ни одного шага — это пишется явно, чтобы постмортем не строил догадок.
-func TestPostMortemsTextTranscriptEmpty(t *testing.T) {
-	tr := storage.Trace{Agent: "dev", Status: storage.TraceTimeout, SessionID: "sess-e"}
-	text := postMortemsText([]storage.Trace{tr}, map[string]string{"sess-e": ""})
-	if !strings.Contains(text, "не сделал ни одного шага") {
-		t.Errorf("нет пометки о пустой сессии: %q", text)
-	}
-}
-
-// TestFormatReviewVerdict — человекочитаемое описание вердикта ревьюера.
-func TestFormatReviewVerdict(t *testing.T) {
-	tests := []struct {
-		name string
-		v    *reviewVerdict
-		want []string
-	}{
-		{
-			name: "passed with everything",
-			v: &reviewVerdict{
-				Passed:          true,
-				CriticalIssues:  []string{"bug A"},
-				SolidViolations: []string{"v1", "v2"},
-				Comments:        []string{"comment"},
-			},
-			want: []string{"passed=yes", "critical=[bug A]", "solid=[v1 | v2]", "comments=[comment]"},
-		},
-		{
-			name: "failed with critical only",
-			v: &reviewVerdict{
-				Passed:         false,
-				CriticalIssues: []string{"bug A", "bug B"},
-			},
-			want: []string{"passed=no", "critical=[bug A | bug B]"},
-		},
-		{
-			name: "empty verdict",
-			v:    &reviewVerdict{},
-			want: []string{"passed=no"},
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := formatReviewVerdict(tt.v)
-			for _, w := range tt.want {
-				if !strings.Contains(got, w) {
-					t.Errorf("formatReviewVerdict = %q, want contain %q", got, w)
-				}
-			}
-		})
-	}
-}
--- a/scripts/.gitea-creds.example
+++ b/scripts/.gitea-creds.example
@@ -0,0 +1,6 @@
+# Секреты для scripts/build-publish-ui.ps1 — НЕ коммитить (git-ignored).
+# Скопируйте этот файл в scripts/.gitea-creds и заполните реальные значения.
+# Формат: по одной `ключ=значение` на строку, строки с # — комментарии.
+GITEA_TOKEN=write:packages-токен
+UPDATE_TOKEN=read:package-токен
+GIT_MAIN_URL=http://gitea.hal9000.home
--- a/scripts/build-publish-ui.ps1
+++ b/scripts/build-publish-ui.ps1
@@ -9,21 +9,12 @@ CI собирает ТОЛЬКО headless-linux (см. .gitea/workflows/ci.yaml)

 Требования:
  - Go с доступным C-компилятором (CGO_ENABLED=1). WinLibs gcc: см. память
-    `mem:binator/cgo-winlibs-gcc`. Каталог с gcc.exe можно задать через
-    GCC_PATH (ниже); если не задан — gcc должен быть уже в PATH.
+    `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
-      PROJECT_PATH=..\..\foo        (опционально) корень проекта (где лежат cmd/
-                                    и go.mod); относительно папки scripts/ или
-                                    абсолютный; без него — папка рядом с
-                                    скриптом
-      GCC_PATH=D:\MinGW\bin         (опционально) каталог, где лежит gcc.exe;
-                                    дописывается в PATH перед проверкой и
-                                    сборкой; абсолютный или относительно
-                                    scripts/; без него — gcc из текущего PATH
  - Ветка уже запушена в `main` (VERSION = commit-<sha7> от текущего HEAD).

 Пример:
@@ -33,13 +24,22 @@ CI собирает ТОЛЬКО headless-linux (см. .gitea/workflows/ci.yaml)
 $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"

-# --- 0. Проверка флага CGO_ENABLED (не зависит от creds) ---
+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)) {
@@ -59,42 +59,6 @@ $giteaUrl = $creds["GIT_MAIN_URL"]
 if (-not $giteaToken) { Write-Error "В $CredsFile нет GITEA_TOKEN (нужен write:packages)." }
 if (-not $giteaUrl)  { Write-Error "В $CredsFile нет GIT_MAIN_URL." }

-# --- 1a. C-тулчейн (gcc): GCC_PATH из creds дописывается в PATH ---
-# Путь абсолютный либо относительно папки scripts/; без GCC_PATH — gcc
-# берётся из уже установленного PATH.
-$gccPath = $creds["GCC_PATH"]
-if ($gccPath -ne "" -and $gccPath) {
-    $gccAbs = Join-Path $ScriptDir $gccPath
-    $gccBin = (Resolve-Path -LiteralPath $gccAbs -ErrorAction SilentlyContinue).Path
-    if (-not $gccBin) {
-        $gccAbs = $gccPath  # не нашлось относительно scripts/ — пробуем как абсолютный
-        $gccBin = (Resolve-Path -LiteralPath $gccAbs -ErrorAction SilentlyContinue).Path
-    }
-    if (-not $gccBin) { Write-Error "GCC_PATH не найден: $gccPath (или относительно $ScriptDir)" }
-    $env:Path = "$gccBin;$env:Path"
-    Write-Host "[gcc] PATH += $gccBin"
-}
-if (-not (Get-Command gcc -ErrorAction SilentlyContinue)) {
-    Write-Host "gcc не найден в PATH. Пример (WinLibs):"
-    Write-Host '  D:\MinGW\bin, затем:
-      GCC_PATH=D:\MinGW\bin — в scripts/.gitea-creds'
-    Write-Error "C-компилятор gcc не найден."
-}
-Write-Host "[ok] gcc: $((gcc --version | Select-Object -First 1))"
-
-# --- 1b. Корень целевого проекта ---
-# PROJECT_PATH из .gitea-creds (относительно папки scripts/) либо, если не задан,
-# папка рядом со скриптом (прежнее поведение).
-$projPath = $creds["PROJECT_PATH"]
-if ($projPath -ne "" -and $projPath) {
-    $RepoRoot = (Resolve-Path -LiteralPath (Join-Path $ScriptDir $projPath)).Path
-    if (-not $RepoRoot) { Write-Error "PROJECT_PATH не найден: $projPath (относительно $ScriptDir)" }
-} else {
-    $RepoRoot = Split-Path -Parent $ScriptDir
-}
-Set-Location $RepoRoot
-Write-Host "[root] $RepoRoot"
-
 # --- 2. Версия = commit-<sha7> текущего HEAD (совпадает с именованием CI) ---
 $sha = (git rev-parse --short HEAD).Trim()
 if (-not $sha) { Write-Error "git rev-parse --short HEAD не дал хэш." }