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

@@ -41,3 +41,14 @@
 - `app.Version` — семантическая major.minor.patch (ручной инкремент: patch=фиксы,
   minor=новая обратно-совместимая функциональность, major=несовместимые изменения). Сейчас 0.2.2.
 - `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)
 

docs/ui-spec.md

@@ -223,7 +223,12 @@
     отбрасываются (буфер ограничен);
   - `Clear()` — очистить при недоступной задаче.
 - Композитор: поле ввода + кнопки команд, подключённые к `ui.Commands` через
-  `SetCommands(c)` (ввод → `SendText`, кнопки → Start/Approve/Skip/Cancel).
+  `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`.

internal/app/app.go

@@ -11,6 +11,7 @@ import (
 	"os/signal"
 	"path/filepath"
 	"strings"
+	"sync"
 	"syscall"
 	"time"
 
@@ -83,6 +84,7 @@ type App struct {
 type FreeChat struct {
 	Runner   analyst.OpenCodeRunner
 	Worktree string
+	mu       sync.Mutex             // защищает sessions (пишется из воркеров роутера)
 	sessions map[chat.UserID]string // uid → opencode sessionID
 }
 
@@ -95,12 +97,18 @@ func NewFreeChat(runner analyst.OpenCodeRunner, worktree string) *FreeChat {
 // и возвращает ответ модели. Сессия продолжается (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
 }
 

internal/chat/router.go

@@ -21,17 +21,35 @@ 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 {
@@ -42,15 +60,51 @@ func NewRouter(onUserMsg func(Incoming)) *Router {
 		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

@@ -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/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

@@ -15,6 +15,10 @@ type ChatPanel interface {
 	Clear()
 	// SetCommands подключает команды к композитору (ввод + кнопки).
 	SetCommands(c *Commands)
+	// SetBoundTask сообщает панели задачу, к которой привязана вкладка
+	// (0 — свободный чат). Кнопка «Перезапустить» (/retry N) активна только
+	// для вкладки с привязанной задачей.
+	SetBoundTask(taskID int64)
 }
 
 // NilChatPanel — no-op реализация ChatPanel для headless-режима и тестов.
@@ -27,6 +31,7 @@ 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 {

internal/ui/chat_panel_test.go

@@ -23,4 +23,32 @@ func TestNilChatPanelNoop(t *testing.T) {
 	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

@@ -21,6 +21,8 @@ type ChatPanel struct {
 	convLbl   *widget.Label
 	input     *widget.Entry
 	commands  *ui.Commands
+	retryBtn  *widget.Button // «Перезапустить» — полный аналог /retry N
+	boundTask int64          // >0 — вкладка привязана к задаче №boundTask
 }
 
 // NewChatPanel создаёт ChatPanel.
@@ -30,6 +32,8 @@ func NewChatPanel() *ChatPanel {
 	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
 }
 
@@ -44,11 +48,32 @@ func (p *ChatPanel) Composer() fyne.CanvasObject {
 		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)

internal/ui/desktop/log_panel.go

@@ -116,21 +116,39 @@ func (p *LogPanel) flush() {
 	}
 }
 
-// render перестраивает текст ленты из буфера с учётом выбранного набора
-// уровней. Пустой набор → пустая лента (без ошибок).
+// render перерисовывает ленту: дописывает в label только новые видимые
+// записи (RenderNew). Если вытеснение задело уже выведенные записи (stale),
+// RenderNew возвращает полный текст — пересобираем label целиком. Так при
+// росте ленты мимо лимита флаш дешёвый (только дельта), а полная пересборка
+// происходит лишь по вытеснению/смене фильтра.
 func (p *LogPanel) render() {
-	p.label.SetText(p.buf.Render(p.selected))
+	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 (колбэки чекбоксов).
+// Вызывается только с потока 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.render()
+	p.label.SetText(p.buf.Render(p.selected))
+	p.buf.ResetRendered()
 }
 
 // filterCaption — подпись кнопки-дропдауна: текущий выбранный набор уровней.

internal/ui/desktop/window.go

@@ -150,6 +150,8 @@ func (w *Window) addTab(sess *ui.Session) {
 	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)
@@ -309,6 +311,9 @@ func (w *Window) bindTaskSession(chatID string, taskID int64) {
 			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()

internal/ui/log_panel.go

@@ -87,6 +87,13 @@ type LogBuffer struct {
 	start   int // индекс первого «живого» элемента (ленивое вытеснение)
 	total   int // суммарный объём текста живых записей [start..], байты
 	maxLen  int // лимит суммарного объёма текста записей, байты
+
+	// Инкрементальная отрисовка (RenderNew): rendered — сколько живых записей
+	// от начала уже выведено в текст ленты; stale — вытеснение задело уже
+	// выведенные записи, так что текст ленты нельзя дополнить дельтом и нужен
+	// полный пересбор. Эти поля поддерживаются только рендером.
+	rendered int
+	stale    bool
 }
 
 // NewLogBuffer создаёт буфер ёмкостью maxLen байт текста записей.
@@ -113,18 +120,36 @@ func (b *LogBuffer) Append(level, text string) bool {
 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
@@ -141,12 +166,55 @@ func (b *LogBuffer) Entries() []LogEntry {
 
 // 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 := b.start; i < len(b.entries); i++ {
+	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

internal/ui/log_panel_test.go

@@ -229,3 +229,92 @@ func TestLogBufferBytesCap(t *testing.T) {
 		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/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
 	}

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
 		}
+		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", "")

scripts/build-publish-ui.ps1

@@ -9,15 +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        (опционально) корень собираемого проекта
-                                    относительно папки scripts/; без него —
-                                    папка рядом со скриптом
+      PROJECT_PATH=..\..\foo        (опционально) корень проекта (где лежат cmd/
+                                    и go.mod); относительно папки scripts/ или
+                                    абсолютный; без него — папка рядом с
+                                    скриптом
+      GCC_PATH=D:\MinGW\bin         (опционально) каталог, где лежит gcc.exe;
+                                    дописывается в PATH перед проверкой и
+                                    сборкой; абсолютный или относительно
+                                    scripts/; без него — gcc из текущего PATH
   - Ветка уже запушена в `main` (VERSION = commit-<sha7> от текущего HEAD).
 
 Пример:
@@ -32,14 +38,8 @@ $Package    = "ratatoskr"
 $Owner      = "kamelion"
 $Filename   = "ratatoskr-windows-amd64.exe"
 
-# --- 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,7 +59,30 @@ $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. Корень целевого проекта ---
+# --- 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"]