perf(chat,update): пул воркеров per-user вместо сериальной очереди + HEAD-проба обновлений

- chat.Router: ограниченный пул chatWorkers=4 воркеров + FIFO-очереди
  per-user (userState/workerLoop/runUser). Порядок сообщений одного UserID
  сохраняется; разные пользователи обрабатываются параллельно (до 4
  одновременных LLM-вызовов), long-poll Telegram не блокируется чужим
  аналитиком. Backpressure по jobs — только на перегруженного пользователя.
- app.FreeChat: sessions под sync.Mutex (защита от data race при параллельных
  воркерах роутера).
- update: ResolveLatest проверяет наличие бинаря HEAD-пробой без скачивания
  тела (fallback GET Range 0-0 при 405/501), сортировка версий по id убыв.;
  один общий http.Client (keep-alive) вместо нового на каждый запрос.
- тесты: порядок/параллелизм per-user в router, HEAD-без-тела и фоллбэк на
  версию без бинаря в update.
- память Serena: инварианты Router/update, примечания по форматированию на Windows.

.serena/memories/conventions.md

@@ -40,4 +40,15 @@
 ## Версии
 - `app.Version` — семантическая major.minor.patch (ручной инкремент: patch=фиксы,
   minor=новая обратно-совместимая функциональность, major=несовместимые изменения). Сейчас 0.2.2.
-- `main.version` (ldflag) — build-идентификатор `commit-<sha7>`, отдельно от app.Version.
+- `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`).

.serena/memories/core.md

@@ -31,13 +31,15 @@ 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 сверяет предprod-версию (binary+в.в) .
+- **Автообновление:** авто = только 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-известное замечание).
 
 ## opencode (v2 HTTP API, >= 1.18.18)
 

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

@@ -2,11 +2,12 @@
 
 ## MinGW/WinLibs для Fyne-сборки на Windows
 - UI (internal/ui/desktop, fyne.io/fyne/v2) требует cgo + C-компилятор для GLFW.
-- Используется **WinLibs** (mingw64) gcc. Bin каталог нужно добавить в PATH перед
-  `scripts/build-publish-ui.ps1`:
-  ```powershell
-  $p = "<...>\mingw64\bin"; $env:Path = "$p;$env:Path"
-  ```
+- Установлен постоянно в `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

docs/ui-spec.md

@@ -157,6 +157,96 @@
 приложение работает 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)

internal/agents/agents.go

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

internal/agents/chat.md

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

internal/app/app.go

@@ -11,6 +11,7 @@ import (
 	"os/signal"
 	"path/filepath"
 	"strings"
+	"sync"
 	"syscall"
 	"time"
 
@@ -73,6 +74,42 @@ 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 читает конфиг и собирает все зависимости.
@@ -212,6 +249,9 @@ func New(configPath, version, updateToken string, noUI bool) (*App, error) {
 	a.Router = router
 	a.Worker = w
 
+	// Свободный LLM-чат (вкладки UI без задачи): общий Runner, свой sessionID на uid.
+	a.FreeChat = NewFreeChat(ocRunner, cfg.Paths.Worktree)
+
 	// /status N читает живое состояние сессии через liveProbe-адаптер.
 	coreCtx.Live = &liveProbe{reg: live}
 
@@ -363,6 +403,10 @@ func (a *App) handleIncoming(inc chat.Incoming) {
 			}
 			a.send(ctx, uid, result.Reply)
 
+		case isUISession(uid):
+			// Свободная UI-вкладка (нет активной задачи): свободный LLM-чат.
+			a.freeChatReply(ctx, uid, text)
+
 		default:
 			a.send(ctx, uid, "Нет активной задачи. /start — создать новую.")
 		}
@@ -427,6 +471,26 @@ func hasArg(text string) bool {
 	return i > 0 && strings.TrimSpace(s[i:]) != ""
 }
 
+// isUISession — true, если UserID принадлежит UI-вкладке-сессии (ui://sess-*).
+func isUISession(uid chat.UserID) bool {
+	return strings.HasPrefix(string(uid), ui.SessionID)
+}
+
+// freeChatReply — ответ свободной LLM-сессии (вкладка UI без активной задачи).
+func (a *App) freeChatReply(ctx context.Context, uid chat.UserID, text string) {
+	if a.FreeChat == nil {
+		a.send(ctx, uid, "Нет активной задачи. /start — создать новую.")
+		return
+	}
+	reply, err := a.FreeChat.Chat(ctx, uid, text)
+	if err != nil {
+		log.Printf("app: free chat %s: %v", uid, err)
+		a.send(ctx, uid, "Ошибка LLM-чата.")
+		return
+	}
+	a.send(ctx, uid, reply)
+}
+
 // ownerUID — куда слать авто-уведомления об обновлении.
 func (a *App) ownerUID() chat.UserID {
 	if a.Config.Telegram.ChatID != "" {

internal/chat/router.go

@@ -21,36 +21,90 @@ type Router struct {
 	// Hook, вызываемый на каждое входящее событие (обычно → process_turn).
 	onUserMsg func(Incoming)
 
-	// Асинхронная обработка входящих: handleIncoming кладёт событие в канал,
-	// воркер-горутина последовательно вызывает onUserMsg. Благодаря этому
-	// long-poll цикл канала (Telegram) не блокируется на время долгого
-	// вызова аналитика и продолжает принимать новые сообщения.
-	incoming chan Incoming
+	// Асинхронная обработка входящих ограниченным пулом воркеров с
+	// упорядоченными очередями per-user (см. chatWorkers, userState).
+	// Благодаря этому long-poll цикл канала (Telegram) не блокируется на время
+	// долгого вызова аналитика, а сообщения разных пользователей не сериализуются
+	// друг за другом: каждый активный пользователь занимает своего воркера.
+	jobs   chan *userState
+	users  map[UserID]*userState
+	userMu sync.Mutex
 
 	// 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 {
 		onUserMsg = func(Incoming) {}
 	}
 	r := &Router{
-		sessions:   map[UserID]any{},
-		routes:     map[UserID]Route{},
-		pending:    map[UserID]PendingQ{},
+		sessions:  map[UserID]any{},
+		routes:    map[UserID]Route{},
+		pending:   map[UserID]PendingQ{},
 		onUserMsg: onUserMsg,
-		incoming:   make(chan Incoming, 256),
+		jobs:      make(chan *userState, chatWorkers),
+		users:     make(map[UserID]*userState),
+	}
+	for i := 0; i < chatWorkers; i++ {
+		go r.workerLoop()
 	}
-	go r.processLoop()
 	return r
 }
 
-// processLoop — воркер асинхронной обработки входящих (FIFO).
-func (r *Router) processLoop() {
-	for inc := range r.incoming {
+// 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()
+
 		r.onUserMsg(inc)
 		r.processed.Add(1)
 	}
@@ -99,9 +153,19 @@ func (r *Router) handleIncoming(inc Incoming) {
 	}
 	r.mu.Unlock()
 
-	// Асинхронная обработка: кладём событие в очередь воркера и сразу
-	// возвращаемся, не блокируя вызывающий long-poll цикл канала.
-	r.incoming <- inc
+	// Асинхронная обработка: кладём событие в 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()
 }
 
 // Send уведомляет пользователя через текущий маршрут. M1 (нет маршрута) — no-op,

internal/chat/router_test.go

@@ -9,8 +9,8 @@ import (
 )
 
 const (
-	uidA UserID = "u-a"
-	uidB UserID = "u-b"
+	uidA UserID  = "u-a"
+	uidB UserID  = "u-b"
 	tg   Address = "tg://123"
 	tui  Address = "tui://local"
 )
@@ -213,3 +213,105 @@ 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])
+	}
+}

internal/events/log.go

@@ -5,6 +5,14 @@ import (
 	"sync"
 )
 
+// Канонические уровни записей лога (фильтр панели «Логи», см. ui.LogLevels).
+const (
+	LevelError   = "error"
+	LevelWarning = "warning"
+	LevelInfo    = "info"
+	LevelDebug   = "debug"
+)
+
 // LogLine — строка лога для панели «Логи».
 type LogLine struct {
 	Level string
@@ -13,6 +21,37 @@ 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 для логов.
 //
 // Логи идут отдельной шиной, чтобы большие объёмы текста не блокировали
@@ -35,7 +74,8 @@ type LogWriter struct {
 	buf strings.Builder
 }
 
-// NewLogWriter создаёт LogWriter, публикующий в шину логов события LogLine{Level:"log"}.
+// NewLogWriter создаёт LogWriter, публикующий строки лога как события
+// LogLine; уровень каждой строки определяется эвристикой ClassifyLevel.
 func NewLogWriter(bus *LogBus) *LogWriter {
 	return &LogWriter{bus: bus.Bus}
 }
@@ -56,7 +96,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: "log", Text: line})
+			w.bus.Publish(LogLine{Level: ClassifyLevel(line), Text: line})
 		}
 	}
 	w.buf.Reset()

internal/events/log_test.go

@@ -21,7 +21,8 @@ func TestLogWriterLines(t *testing.T) {
 	if !ok {
 		t.Fatalf("got %T, want LogLine", first)
 	}
-	if ll.Text != "first line" || ll.Level != "log" {
+	// строка без маркеров ошибок/отладки — информационная
+	if ll.Text != "first line" || ll.Level != LevelInfo {
 		t.Fatalf("unexpected first line: %+v", ll)
 	}
 
@@ -73,4 +74,49 @@ func TestLogWriterMultiSplit(t *testing.T) {
 	if strings.Join(texts, ",") != "line1,line2,line3" {
 		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},
+		{"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)
+	}
 }

internal/opencode/client.go

@@ -64,9 +64,6 @@ func (c *Client) do(ctx context.Context, method, path, op string, body []byte) (
 	}
 	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 {
@@ -79,12 +76,12 @@ func (c *Client) do(ctx context.Context, method, path, op string, body []byte) (
 	}
 	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))
+			log.Printf("opencode api %s response: status %d", op, resp.StatusCode)
 		}
 		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))
+		log.Printf("opencode api %s response (%d bytes)", op, len(b))
 	}
 	return b, nil
 }

internal/ui/chat_panel.go

@@ -0,0 +1,44 @@
+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 "🤖 "
+	}
+}

internal/ui/chat_panel_test.go

@@ -0,0 +1,54 @@
+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)
+	}
+}

internal/ui/commands.go

@@ -30,8 +30,14 @@ func (c *Commands) Cancel() { c.Submit("/cancel") }
 // Skip — пропустить сбор, сформировать черновик (/skip).
 func (c *Commands) Skip() { c.Submit("/skip") }
 
-// Retry — перезапустить задачу N (/retry N).
-func (c *Commands) Retry(id int64) { c.Submit(fmt.Sprintf("/retry %d", id)) }
+// 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))
+}
 
 // Status — запросить статус задачи N (/status N).
 func (c *Commands) Status(id int64) { c.Submit(fmt.Sprintf("/status %d", id)) }

internal/ui/desktop/chat_panel.go

@@ -0,0 +1,112 @@
+//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)

internal/ui/desktop/log_panel.go

@@ -0,0 +1,193 @@
+//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)

internal/ui/desktop/maximize_windows.go

@@ -0,0 +1,48 @@
+//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)
+}

internal/ui/desktop/state_panel.go

@@ -0,0 +1,50 @@
+//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)

internal/ui/desktop/task_detail_panel.go

@@ -0,0 +1,54 @@
+//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)

internal/ui/desktop/task_list_panel.go

@@ -0,0 +1,78 @@
+//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)

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,44 +20,43 @@ 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
 
-	// состояние списка
-	mu       sync.Mutex // защищает tasks
-	tasks    []storage.Task
+	// состояние выбора (живёт в окне, спец 12.10)
 	selected int64
 
 	// виджеты
-	list      *widget.List
-	titleLbl  *widget.Label
-	statusLbl *widget.Label
-	detailLbl *widget.Label
-	convLbl   *widget.Label
-	logsLbl   *widget.Label
-	stateLbl  *widget.Label
-	input     *widget.Entry
+	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>
 
 	hsplit *container.Split
-	vsplit *container.Split
 
 	onQuit func()
 }
@@ -66,12 +65,13 @@ type Window struct {
 func New(appID string, store ui.Store) *Window {
 	fa := app.NewWithID(appID)
 	w := &Window{
-		fyneApp: fa,
-		store:   store,
+		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,48 +87,13 @@ func (w *Window) SetOnQuit(fn func()) { w.onQuit = fn }
 
 // build собирает виджеты и раскладку.
 func (w *Window) build() {
-	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.detail = NewTaskDetailPanel()
+	w.state = NewStatePanel()
+	w.logs = NewLogPanel()
 
 	// Список задач (слева)
-	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)
-	}
+	w.taskList = NewTaskListPanel()
+	w.taskList.OnSelect(func(id int64) { w.openTaskTab(id) })
 
 	quitBtn := widget.NewButtonWithIcon("Завершить", theme.LogoutIcon(), func() {
 		w.saveLayout()
@@ -136,104 +101,130 @@ func (w *Window) build() {
 			w.onQuit()
 		}
 	})
-	left := container.NewBorder(nil, quitBtn, nil, nil, w.list)
+	left := container.NewBorder(nil, quitBtn, nil, nil, w.taskList.Widget())
 
-	// Рабочая область: детали сверху, диалог снизу (сплит 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
+	// Центр: вкладки-сессии + кнопка «Новый чат».
+	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)
 
 	// Нижняя панель: вкладки «Логи» + «Состояние».
 	bottomTabs := container.NewAppTabs(
-		container.NewTabItem("Логи", container.NewScroll(w.logsLbl)),
-		container.NewTabItem("Состояние", container.NewScroll(w.stateLbl)),
+		container.NewTabItem("Логи", w.logs.Widget()),
+		container.NewTabItem("Состояние", w.state.Widget()),
 	)
+	bottom := container.NewBorder(nil, nil, nil, nil, bottomTabs)
 
-	// Ввод + кнопки команд
-	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)
+	w.hsplit = container.NewHSplit(left, container.NewVSplit(center, bottom))
+	w.win.SetContent(w.hsplit)
 
 	// Восстановление layout из Preferences.
 	pref := w.fyneApp.Preferences()
 	w.hsplit.SetOffset(pref.FloatWithFallback(splitHPref, 0.30))
-	w.vsplit.SetOffset(pref.FloatWithFallback(splitVPref, 0.45))
 
 	// Начальный снимок списка.
 	w.refreshList()
+
+	// Открываем свободную вкладку-сессию по умолчанию.
+	w.addFreeTab()
 }
 
-// saveLayout сохраняет текущие позиции сплитов в Preferences.
-// Вызывается при сворачивании окна и перед полным выходом.
-func (w *Window) saveLayout() {
-	pref := w.fyneApp.Preferences()
-	pref.SetFloat(splitHPref, w.hsplit.Offset)
-	pref.SetFloat(splitVPref, w.vsplit.Offset)
+// 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)))
 }
 
-// taskTitle — строка в списке задач.
-func taskTitle(t storage.Task) string {
-	title := t.Title
-	if title == "" {
-		title = "(без названия)"
+// 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)
+}
+
+// tabForAddress возвращает вкладку по адресу сессии.
+func (w *Window) tabForAddress(addr chat.Address) *container.TabItem {
+	for tab, s := range w.tabSession {
+		if s.Address == addr {
+			return tab
+		}
 	}
-	return title + "\n" + string(t.Status)
+	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(formatRole(h.Role))
+		b.WriteString(ui.FormatRole(h.Role))
 		b.WriteString(h.Content)
 		b.WriteString("\n\n")
 	}
@@ -246,19 +237,31 @@ func (w *Window) selectTask(id int64) {
 	if b.Len() == 0 {
 		b.WriteString("Нет сообщений. /start — начать задачу.")
 	}
-	w.convLbl.SetText(b.String())
-
-	// Состояние: сброс к снимку задач.
-	w.refreshState(ctx, id)
+	return b.String()
 }
 
-func formatRole(role string) string {
-	switch role {
-	case "user":
-		return "👤 "
-	default:
-		return "🤖 "
+// 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)
 }
 
 // refreshState — снимок «Состояния» выбранной задачи (агенты + трейсы).
@@ -267,18 +270,7 @@ func (w *Window) refreshState(ctx context.Context, id int64) {
 	if err != nil {
 		return
 	}
-	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())
+	w.state.SetText(ui.StateText(traces))
 }
 
 // refreshList перечитывает список задач из Store (снимок).
@@ -289,56 +281,46 @@ func (w *Window) refreshList() {
 		log.Printf("ui: list tasks: %v", err)
 		return
 	}
-	w.mu.Lock()
-	w.tasks = tasks
-	selected := w.selected
-	w.mu.Unlock()
-
-	if w.list != nil {
-		w.list.Refresh()
-	}
-	_ = selected
+	w.taskList.SetTasks(tasks)
+	w.taskList.Select(w.selected)
 }
 
-// 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)
+// appendLog добавляет запись в панель «Логи» (делегирует в LogPanel).
+func (w *Window) appendLog(level, text string) {
+	w.logs.Append(level, text)
 }
 
-// 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) {
+// submitText отправляет ввод пользователя из вкладки в Router.
+func (w *Window) submitText(uid chat.UserID, addr chat.Address, text string) {
 	if w.handler != nil {
 		w.handler(chat.Incoming{
-			UserID:  ui.UID,
-			Address: ui.Address,
+			UserID:  uid,
+			Address: addr,
 			Channel: w,
 			Msg:     chat.Message{Text: text},
 		})
 	}
 }
 
+// bindTaskSession связывает свободную вкладку с созданной задачей: когда
+// /start в свободном табе создал задачу с ChatID == UserID этой вкладки,
+// вкладка становится task-сессией (спец: каждая задача — своя вкладка).
+func (w *Window) bindTaskSession(chatID string, taskID int64) {
+	for addr, s := range w.sessions {
+		if string(s.UserID) != chatID || s.BoundTask != 0 {
+			continue
+		}
+		s.BoundTask = taskID
+		if 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).
@@ -347,6 +329,7 @@ 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()
@@ -355,30 +338,37 @@ func (w *Window) Run(ctx context.Context) error {
 	return nil
 }
 
-// Send доставляет сообщение Core в диалог окна.
-func (w *Window) Send(_ context.Context, _ chat.Address, m chat.Message) error {
+// 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
+	}
 	text := m.Text
 	if len(m.Options) > 0 {
 		var sb strings.Builder
 		sb.WriteString(text)
-		for i, opt := range m.Options {
+		for _, opt := range m.Options {
 			sb.WriteString("\n")
 			sb.WriteString(opt.Label)
-			_ = i
 		}
 		text = sb.String()
 	}
-	fyne.Do(func() { w.appendConv("🤖 " + text) })
+	fyne.Do(func() { panel.Append("🤖 " + text) })
 	return nil
 }
 
-// Ask — вопрос с вариантами (отображается в диалоге).
-func (w *Window) Ask(_ context.Context, _ chat.Address, m chat.Message) error {
+// Ask — вопрос с вариантами (отображается в диалоге вкладки).
+func (w *Window) Ask(_ context.Context, to chat.Address, m chat.Message) error {
+	panel, ok := w.panels[to]
+	if !ok {
+		return nil
+	}
 	text := m.Text
 	for _, opt := range m.Options {
 		text += "\n" + opt.Label
 	}
-	fyne.Do(func() { w.appendConv("❓ " + text) })
+	fyne.Do(func() { panel.Append("❓ " + text) })
 	return nil
 }
 
@@ -395,6 +385,8 @@ func (w *Window) Close() error {
 func (w *Window) OnTaskCreated(e events.TaskCreated) {
 	fyne.Do(func() {
 		w.refreshList()
+		// /start в свободной вкладке: вкладка привязывается к задаче.
+		w.bindTaskSession(e.ChatID, e.ID)
 		if w.selected == 0 {
 			w.selectTask(e.ID)
 		}
@@ -425,73 +417,41 @@ func (w *Window) OnTaskStatusChanged(e events.TaskStatusChanged) {
 		if w.selected == e.ID {
 			w.selectTask(e.ID)
 		}
-		w.appendState(taskStatusLine(e))
+		w.state.Append(ui.TaskStatusText(e))
 	})
 }
 
 func (w *Window) OnHistoryAppended(e events.HistoryAppended) {
 	fyne.Do(func() {
-		if w.selected == e.TaskID {
-			w.appendConv(formatRole(e.Role) + e.Content)
+		// история приходит в диалог вкладки задачи
+		for addr, s := range w.sessions {
+			if s.BoundTask == e.TaskID {
+				if panel, ok := w.panels[addr]; ok {
+					panel.Append(ui.FormatRole(e.Role) + e.Content)
+				}
+			}
 		}
 	})
 }
 
 func (w *Window) OnTraceAppended(e events.TraceAppended) {
 	fyne.Do(func() {
-		w.appendState(strings.ToUpper(e.Agent) + ": " + string(e.Status))
+		w.state.Append(ui.TraceLine(e.Agent, e.Status))
 	})
 }
 
 func (w *Window) OnAgentActivity(e events.AgentActivity) {
 	fyne.Do(func() {
-		w.appendState(strings.ToUpper(e.Agent) + " → " + e.Stage)
+		w.state.Append(ui.ActivityLine(e.Agent, e.Stage))
 	})
 }
 
 func (w *Window) OnLog(e events.LogLine) {
-	fyne.Do(func() { w.appendLog(e.Text) })
+	w.appendLog(e.Level, e.Text)
 }
 
-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:])
-}
+// compile-time проверка: окно реализует chat.Channel и ui.View.
+var (
+	_ chat.Channel = (*Window)(nil)
+	_ ui.View      = (*Window)(nil)
+)

internal/ui/log_panel.go

@@ -0,0 +1,226 @@
+// 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()
+}

internal/ui/log_panel_test.go

@@ -0,0 +1,320 @@
+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)
+	}
+}

internal/ui/session.go

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

internal/ui/session_test.go

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

internal/ui/state_panel.go

@@ -0,0 +1,99 @@
+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:])
+}

internal/ui/state_panel_test.go

@@ -0,0 +1,50 @@
+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("строка")
+}

internal/ui/task_detail.go

@@ -0,0 +1,37 @@
+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
+}

internal/ui/task_detail_test.go

@@ -0,0 +1,36 @@
+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()
+}

internal/ui/task_list_panel.go

@@ -0,0 +1,40 @@
+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)
+}

internal/ui/task_list_panel_test.go

@@ -0,0 +1,40 @@
+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 не вызывает колбэки — нет виджета, но вызовы безопасны.
+}

internal/update/update.go

@@ -31,7 +31,9 @@ import (
 	"os/exec"
 	"path/filepath"
 	"runtime"
+	"sort"
 	"strings"
+	"sync"
 	"time"
 )
 
@@ -50,6 +52,11 @@ 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.
@@ -118,16 +125,26 @@ 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(url string) ([]byte, error) {
-	req, err := http.NewRequest(http.MethodGet, url, nil)
+func (u *Updater) httpGet(ctx context.Context, url string) ([]byte, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
 	if err != nil {
 		return nil, err
 	}
 	if u.Token != "" {
 		req.Header.Set("Authorization", "token "+u.Token)
 	}
-	resp, err := (&http.Client{Timeout: 30 * time.Second}).Do(req)
+	resp, err := u.httpClient().Do(req)
 	if err != nil {
 		return nil, err
 	}
@@ -138,6 +155,61 @@ func (u *Updater) httpGet(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 — вызывающий
 // решает, логировать и пропустить.
@@ -167,8 +239,12 @@ type pkgVersion struct {
 // ResolveLatest определяет идентификатор новейшей применимой версии пакета.
 // Бинарь/метаданные читаем из КОНКРЕТНОЙ версии, а не из pseudo-`latest`,
 // чтобы companion-файлы и бинарь всегда брались из одного снимка.
+//
+// Применимость версии проверяем НАЛИЧИЕМ бинаря платформы (HEAD без тела),
+// а не скачиванием полного файла: при N версиях это N запросов заголовков
+// вместо N×(размер бинаря) байт.
 func (u *Updater) ResolveLatest(ctx context.Context) (string, error) {
-	b, err := u.httpGet(u.versionsURL())
+	b, err := u.httpGet(ctx, u.versionsURL())
 	if err != nil {
 		return "", err
 	}
@@ -176,30 +252,28 @@ 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
 		}
-		// версия применима, только если в ней опубликован бинарь нашей платформы
-		if _, err := u.httpGet(u.fileURL(v.Ver, want)); err != nil {
-			continue
+		exists, ferr := u.fileExists(ctx, u.fileURL(v.Ver, want))
+		if ferr != nil {
+			continue // сетевые ошибки пробы не роняют проверку
 		}
-		if v.ID > bestID {
-			bestID = v.ID
-			best = v.Ver
+		if exists {
+			return v.Ver, nil
 		}
 	}
-	return best, nil
+	return "", nil
 }
 
 // Download скачивает бинарь конкретной версии во временный файл и возвращает
 // путь к нему. Файл: <Dir>/.ratatoskr.<ver>.new.
 func (u *Updater) Download(ctx context.Context, version string) (string, error) {
-	b, err := u.httpGet(u.fileURL(version, PlatformFilename()))
+	b, err := u.httpGet(ctx, u.fileURL(version, PlatformFilename()))
 	if err != nil {
 		return "", err // уже U3
 	}
@@ -216,7 +290,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(u.fileURL(version, PlatformFilename()+".sha256"))
+	b, err := u.httpGet(ctx, u.fileURL(version, PlatformFilename()+".sha256"))
 	if err != nil {
 		return "", err
 	}
@@ -352,4 +426,4 @@ func (u *Updater) SwapAndRestart(file string) error {
 	// успешный старт нового процесса — текущий завершаем
 	os.Exit(0)
 	return nil
-}
+}

internal/update/update_test.go

@@ -9,6 +9,7 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
+	"sync/atomic"
 	"testing"
 )
 
@@ -41,7 +42,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 {
+		if r.Method != http.MethodGet && r.Method != http.MethodHead {
 			http.Error(w, "method", http.StatusMethodNotAllowed)
 			return
 		}
@@ -58,7 +59,10 @@ func mockGitea(t *testing.T, bin []byte, version, checksum string) *httptest.Ser
 			http.NotFound(w, r)
 			return
 		}
-		_, _ = w.Write(body)
+		if r.Method == http.MethodGet {
+			_, _ = w.Write(body)
+		}
+		// HEAD — просто 200, тело не пишем
 	})
 	return httptest.NewServer(mux)
 }
@@ -133,6 +137,104 @@ 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", "")
@@ -249,4 +351,4 @@ func errorsAs(err error, target **Error) bool {
 		err = c.Unwrap()
 	}
 	return false
-}
+}

scripts/build-publish-ui.ps1

@@ -9,12 +9,21 @@ CI собирает ТОЛЬКО headless-linux (см. .gitea/workflows/ci.yaml)
 
 Требования:
   - Go с доступным C-компилятором (CGO_ENABLED=1). WinLibs gcc: см. память
-    `mem:toolchain/cgo-winlibs-gcc` — bin нужно добавить в PATH перед запуском.
+    `mem:binator/cgo-winlibs-gcc`. Каталог с gcc.exe можно задать через
+    GCC_PATH (ниже); если не задан — gcc должен быть уже в 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).
 
 Пример:
@@ -24,22 +33,13 @@ 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"
 
-Set-Location $RepoRoot
-
-# --- 0. Проверка C-тулчейна ---
+# --- 0. Проверка флага CGO_ENABLED (не зависит от creds) ---
 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,6 +59,42 @@ $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 не дал хэш." }