Revert "feat(opencode): рабочий serve для dev стартует из папки репозитория; пул покрывает внешним сервером подкаталоги"

This reverts commit 2005421739.

.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,19 +31,22 @@ 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-известное замечание).
+- **Telegram toggle:** `telegram.enabled` (дефолт true, preset в `Load` до unmarshal, т.к. `applyDefaults` для bool не различает явный false). При `false` канал не создаётся/не крепится в Router и long-poll не стартует — сетевых вызовов к api.telegram.org нет; token/chat_id не валидируются.
 
 ## opencode (v2 HTTP API, >= 1.18.18)
 
 - Интеграция с субагентами — через headless `opencode serve`, **v2 API** (`/api/*`). Версия opencode >= 1.18.18.
-- **Хардпин модели:** при создании сессии читается top-level `model` из конфига opencode (`internal/opencode/config.go`, JSONC-стрип) и передаётся в `POST /api/session` как `{"model":{providerID,id}}`.
-- **О5 WARN (устойчивость к v1-конфигу):** конфиг по старой схеме молча игнорируется v2; провайдер без api → unsupported модели → fallback. Ratatoskr не чинит сам, но логирует warning; фактическая модель ответа сравнивается с ожидаемой. Правильный v2-вид: `api:{type:"aisdk",package,url}`, `request.headers` вместо `options.headers`.
+- **Модель — только глобальный конфиг opencode.** Ratatoskr модель не выбирает и про неё не знает: opencode сам берёт модель по умолчанию из своего глобального конфига. Код opencode-конфиг не читает (config.go удалён).
+- **Свой агент:** при создании сессии в `POST /api/session` передаётся `agent` (analyst/dev/reviewer/chat/postmortem) из встроенных определений. Агенты распаковываются в `<worktree>/.opencode/agent/*.md` (opencode находит через project-каталог `.opencode`); `OPENCODE_CONFIG_DIR` НЕ выставлять — он перенаправляет Global.Path.config и ломает глобальный конфиг (модель/провайдеры) → падение в fallback.
 - **Поллинг вердикта:** `POST /api/session/:id/prompt` (durable admit) → `GET /api/session/:id/message?order=desc&limit=200` (новые assistant-сообщения, текст в `content[].type=="text"`) → завершение = `GET /api/session/active` без сессии + финальное assistant-сообщение, стабильное `settlePolls=2` опроса. `POST .../interrupt` вместо abort.
 
 ## Контракты (не ломать)

README.md

@@ -95,11 +95,11 @@ make run       # build + ./ratatoskr -config config.yaml
 
 ```yaml
 telegram:
-  token: "..."            # TG_TOKEN
-  chat_id: "..."          # TG_CHAT_ID
+  enabled: true            # false — отключить Telegram (без сетевых вызовов к api.telegram.org)
+  token: "..."            # TG_TOKEN (обязательно, если enabled)
+  chat_id: "..."          # TG_CHAT_ID (обязательно, если enabled)
 opencode:
   bin: "opencode"
-  config_dir: "./agents"  # каталог, куда распаковываются встроенные агенты
 paths:
   db: "./ratatoskr.db"        # дефолт; резолвится от каталога бинаря (не от cwd)
   worktree: "./worktrees"     # то же правило «всё рядом с .exe»
@@ -131,25 +131,22 @@ update:
 
 ## Интеграция с opencode (субагенты)
 
-Субагенты (analyst / dev / reviewer) запускаются через **headless** `opencode serve`
+Субагенты (analyst / dev / reviewer / postmortem) запускаются через **headless** `opencode serve`
 по **v2 HTTP API** (префикс `/api/*`). Требуемая версия opencode: **>= 1.18.18**
 (сборки с v2 HTTP API). Старый бинарь, отвечающий только на `/global/health`,
 не подходит: healthcheck падает с понятной ошибкой (класс O1).
 
 Что делает обёртка (`internal/opencode`):
 
-- **Хардпин модели.** При создании сессии в конфиге opencode ищется top-level
-  `"model"` (`internal/opencode/config.go`) и передаётся в `POST /api/session`
-  как `{"model":{providerID,id}}`. Это убирает зависимость от fallback-логики
-  opencode (которая молча выбирает «дефолтную» запись, если модель не задана).
-- **Весь код резолва модели устойчив к этому классу проблем (класс O5 WARN):**
-  - если конфиг не читается / в нём нет `model` — в логи пишется warning;
-  - фактическая модель ответа (из финального assistant-сообщения) сравнивается
-    с ожидаемой; расхождение логируется как warning;
-  - конфиг, написанный по **старой v1-схеме** (`provider.X.npm` / `options`),
-    молча игнорируется v2 — обёртка этого не «чинит» сама, но предупреждает.
-    Правильный v2-вид провайдера — `api: { type:"aisdk", package, url }` и
-    `request.headers` вместо `options.headers`.
+- **Модель — только глобальный конфиг opencode.** ratatoskr модель не выбирает
+  и про неё не знает: opencode сам берёт модель по умолчанию из своего
+  глобального конфига (`~/.config/opencode/opencode.jsonc`). Наш код конфиг
+  opencode не читает.
+- **Свой агент.** При создании сессии в `POST /api/session` передаётся имя
+  встроенного агента ratatoskr (analyst/dev/reviewer/chat/postmortem). Агенты
+  распаковываются в `<worktree>/.opencode/agent/*.md`, где opencode находит
+  их через project-каталог `.opencode` (см. `internal/agents`); глобальный
+  конфиг при этом не трогается.
 - **Поллинг вердикта.** Промпт отправляется неблокирующе (`POST .../prompt` →
   durable admit), вердикт собирается из новых assistant-сообщений
   (`GET .../message`); завершение ответа — сессия ушла из активных дренажей
@@ -173,6 +170,18 @@ update:
 В `internal/core` фазы `propose` и `ready` обрабатываются одинаково (применить черновик,
 проверить репозитории, поставить `ready` и отдать резюме).
 
+## Постмортем после failed/timeout
+
+Когда задача завершилась `failed` или `timeout`, воркер дополнительно запускает
+**постмортем-анализ** (`internal/worker/postmortem.go`, agent `postmortem`):
+
+- анализирует сессии dev/reviewer (промпты и выводы из `traces`);
+- оценивает законченность этапов и причины сбоя;
+- сохраняет результат как trace `agent=postmortem` и шлёт владельцу уведомление
+  «🔍 анализ (после <статус>): почему так случилось / что сделать».
+
+Статус задачи постмортем не меняет; сбои самого анализа не влияют на исход задачи.
+
 ## Автообновление из Gitea Packages
 
 Бинарь умеет сам себя обновлять из generic-пакета в Gitea. Модель:

config.yaml.example

@@ -1,18 +1,20 @@
 # ratatoskr-go пример конфигурации.
 # Можно не указывать поля, у которых есть дефолт (см. internal/config/types.go).
-# Обязательно: telegram.token + telegram.chat_id
+# Если telegram.enabled: true (дефолт) — обязательно: telegram.token + telegram.chat_id.
 
 telegram:
-  token: "${TG_TOKEN}"        # токен Telegram бота (обязательно)
-  chat_id: "${TG_CHAT_ID}"    # ID чата (обязательно)
+  enabled: true                 # false — полностью отключить Telegram (без сетевых вызовов)
+  token: "${TG_TOKEN}"        # токен Telegram бота (обязательно, если enabled)
+  chat_id: "${TG_CHAT_ID}"    # ID чата (обязательно, если enabled)
 
 # Всё ниже — опционально, показаны дефолты:
 # opencode:
 #   bin: "opencode"
-#   config: "/путь/к/opencode.json"      # файл-конфиг модели (OPENCODE_CONFIG)
-#   config_dir: "./agents"               # каталог с агентами (OPENCODE_CONFIG_DIR)
 #   hard_timeout: "20m"
 #   idle_timeout: "5m"
+#
+# Агенты (analyst/dev/reviewer/...) распаковываются автоматически в
+# <worktree>/.opencode/agent/*.md; конфиг opencode для этого не нужен.
 
 # git (источник репозиториев для git clone)
 #   base_url: "http://gitea.hal9000.home"   # базовый URL git-хоста (обязательно для клонирования)

internal/agents/agents.go

@@ -1,12 +1,10 @@
 // Package agents — встроенные агенты opencode (analyst, dev, ...).
 //
 // Агенты зашиты в бинарь через go:embed и распаковываются при запуске
-// в каталог OPENCODE_CONFIG_DIR (по умолчанию ./agents рядом с бинарём),
-// чтобы opencode находил их независимо от того, где запущен ratatoskr.
-//
-// opencode сканирует OPENCODE_CONFIG_DIR как каталог .opencode: агенты
-// ищутся в поддиректории agents/ (мн.ч.), а не в корне. Поэтому распаковка
-// идёт в <dir>/agents/*.md.
+// в project-каталог <worktree>/.opencode/agent/*.md. opencode при serve
+// (cwd = worktree) обнаруживает .opencode поднятием вверх (ConfigPaths) и
+// находит агентов по шаблону {agent,agents}/**/*.md. Глобальный конфиг
+// opencode остаётся нетронутым (OPENCODE_CONFIG_DIR не выставляем).
 package agents
 
 import (
@@ -21,9 +19,9 @@ var FS embed.FS
 //
 // Держим в курсе: если добавить файл в каталог, он автоматически попадёт
 // в FS, но для детерминированной распаковки список лучше дополнять здесь.
-var Names = []string{"analyst", "dev", "reviewer", "chat"}
+var Names = []string{"analyst", "dev", "reviewer", "chat", "postmortem"}
 
-// WriteTo распаковывает всех встроенных агентов в каталог dir/agents
+// WriteTo распаковывает всех встроенных агентов в каталог dir/agent
 // (создаёт его). Файлы перезаписываются — встроенная копия всегда актуальна.
 func WriteTo(dir string) error {
 	agentsDir := filepath.Join(dir, "agents")

internal/agents/agents_test.go

@@ -13,7 +13,7 @@ func TestWriteTo(t *testing.T) {
 		t.Fatalf("WriteTo: %v", err)
 	}
 	for _, name := range Names {
-		// opencode ищет агентов в поддиректории agents/, как у .opencode
+		// opencode ищет агентов в поддиректории agent/ (или agents/) внутри .opencode
 		p := filepath.Join(dir, "agents", name+".md")
 		data, err := os.ReadFile(p)
 		if err != nil {

internal/agents/analyst.md

@@ -2,6 +2,20 @@
 name: analyst
 description: Аналитик Ratatoskr — помогает сформулировать задачу разработки и возвращает структурированное решение в JSON
 mode: primary
+tools:
+  read: true
+  write: true
+  edit: false
+  bash: true
+  grep: true
+  glob: true
+  websearch: false
+  webfetch: false
+permission:
+  question: deny
+  edit: deny
+  bash:
+    "*": allow
 ---
 
 Ты — аналитик в конвейере Ratatoskr. Пользователь ставит задачу разработки. Ты помогаешь

internal/agents/dev.md

@@ -2,6 +2,20 @@
 name: dev
 description: Разработчик Ratatoskr — реализует задачу в репозитории по готовым критериям
 mode: primary
+tools:
+  read: true
+  write: true
+  edit: true
+  bash: true
+  grep: true
+  glob: true
+  websearch: false
+  webfetch: false
+permission:
+  question: deny
+  edit: allow
+  bash:
+    "*": allow
 ---
 
 Ты — dev-агент в конвейере Ratatoskr. Получаешь готовое задание и реализуешь его в коде.

internal/agents/postmortem.md

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

internal/agents/reviewer.md

@@ -2,6 +2,20 @@
 name: reviewer
 description: Ревьюер Ratatoskr — строго проверяет ветку работы dev-агента (качество, безопасность, SOLID) и возвращает вердикт в JSON
 mode: primary
+tools:
+  read: true
+  write: true
+  edit: false
+  bash: true
+  grep: true
+  glob: true
+  websearch: false
+  webfetch: false
+permission:
+  question: deny
+  edit: deny
+  bash:
+    "*": allow
 ---
 
 Ты — ревьюер в конвейере Ratatoskr. Проверяешь работу dev-агента в feature-ветке **жёстко и придирчиво**. Твоя цель — не дать плохому коду попасть в основную ветку.

internal/analyst/analyst.go

@@ -54,14 +54,75 @@ type AnalystResponse struct {
 	Title       string          `json:"title"`
 	Goal        string          `json:"goal"`
 	Repo        string          `json:"repo"`  // одиночный репо (обратная совместимость)
-	Repos       []string `json:"repos"`  // список репо (основной)
+	Repos       json.RawMessage `json:"repos"` // список репо (основной); устойчив к строке
 	Why         string          `json:"why"`
 	AC          string          `json:"ac"`
+	Steps       json.RawMessage `json:"steps"` // список этапов; устойчив к строке
 	Questions   []string        `json:"questions"`
 	ChatReply   string          `json:"chat_reply"`
 	AbortReason string          `json:"abort_reason"`
 }
 
+// reposList нормализует поле repos: модель может вернуть либо массив
+// ["a","b"], либо строку "a,b" (иногда с пробелами). Пустое значение → nil.
+func (r *AnalystResponse) reposList() []string {
+	if r.Repos == nil {
+		return nil
+	}
+	var arr []string
+	if err := json.Unmarshal(r.Repos, &arr); err == nil {
+		return arr
+	}
+	var s string
+	if err := json.Unmarshal(r.Repos, &s); err != nil {
+		return nil
+	}
+	var out []string
+	for _, p := range strings.Split(s, ",") {
+		p = strings.TrimSpace(p)
+		if p != "" {
+			out = append(out, p)
+		}
+	}
+	return out
+}
+
+// validSteps отбрасывает записи без title.
+func validSteps(arr []storage.Step) []storage.Step {
+	out := make([]storage.Step, 0, len(arr))
+	for _, st := range arr {
+		if st.Title == "" {
+			continue
+		}
+		out = append(out, st)
+	}
+	return out
+}
+
+// stepsList возвращает этапы, устойчиво к формату модели: массив объектов
+// {"title","ac"} либо строка (пустая → nil; содержащая JSON-массив → парсится;
+// иначе игнорируется). Записи без title отбрасываются.
+func (r *AnalystResponse) stepsList() []storage.Step {
+	if r.Steps == nil {
+		return nil
+	}
+	var arr []storage.Step
+	if err := json.Unmarshal(r.Steps, &arr); err == nil {
+		return validSteps(arr)
+	}
+	var s string
+	if err := json.Unmarshal(r.Steps, &s); err != nil {
+		return nil
+	}
+	if strings.TrimSpace(s) == "" {
+		return nil
+	}
+	if err := json.Unmarshal([]byte(s), &arr); err == nil {
+		return validSteps(arr)
+	}
+	return nil
+}
+
 // Decide реализует core.Decider через открытый код.
 func (a *Analyst) Decide(ctx context.Context, history []core.Message, draft storage.Task, force bool) (core.Decision, error) {
 	agent := a.Agent
@@ -85,6 +146,7 @@ func (a *Analyst) Decide(ctx context.Context, history []core.Message, draft stor
 		Repos:   draft.EffectiveRepos(),
 		Why:     draft.Why,
 		AC:      draft.AC,
+		Steps:   draft.Steps,
 		History: hist,
 		Force:   force,
 	}
@@ -104,12 +166,7 @@ func (a *Analyst) Decide(ctx context.Context, history []core.Message, draft stor
 
 	// 4. парсим вердикт
 	verdict := opencode.ExtractVerdict(res.Stdout)
-	log.Printf("analyst: verdict tail: %s", truncate(verdict, 2000))
 	obj, ok := opencode.ExtractJSON(verdict)
-	if ok {
-		b, _ := json.Marshal(obj)
-		log.Printf("analyst: extracted json: %s", truncate(string(b), 1000))
-	}
 	if !ok {
 		return core.Decision{}, fmt.Errorf("%w: нет JSON в выводе аналитика", ErrDecodeFail)
 	}
@@ -123,6 +180,8 @@ func (a *Analyst) Decide(ctx context.Context, history []core.Message, draft stor
 		return core.Decision{}, fmt.Errorf("%w: %v", ErrDecodeFail, err)
 	}
 
+	log.Printf("analyst: вердикт: %s", truncate(formatVerdict(&ar), 2000))
+
 	// 5. валидация
 	if err := validateResponse(&ar); err != nil {
 		return core.Decision{}, fmt.Errorf("%w: %v", ErrValidation, err)
@@ -144,10 +203,10 @@ func (a *Analyst) Decide(ctx context.Context, history []core.Message, draft stor
 	if ar.Repo != "" {
 		dec.Draft.Repo = ar.Repo
 	}
-	if len(ar.Repos) > 0 {
-		dec.Draft.Repos = ar.Repos
+	if repos := ar.reposList(); len(repos) > 0 {
+		dec.Draft.Repos = repos
 		// Синхронизируем одиночный repo для старых потребителей.
-		dec.Draft.Repo = strings.Join(ar.Repos, ",")
+		dec.Draft.Repo = strings.Join(repos, ",")
 	}
 	if ar.Why != "" {
 		dec.Draft.Why = ar.Why
@@ -155,6 +214,9 @@ func (a *Analyst) Decide(ctx context.Context, history []core.Message, draft stor
 	if ar.AC != "" {
 		dec.Draft.AC = ar.AC
 	}
+	if steps := ar.stepsList(); len(steps) > 0 {
+		dec.Draft.Steps = steps
+	}
 
 	return dec, nil
 }
@@ -183,7 +245,7 @@ func validateResponse(ar *AnalystResponse) error {
 			return fmt.Errorf("phase=ask, но нет ни chat_reply, ни questions")
 		}
 	case "propose":
-		if ar.Title == "" && ar.Goal == "" && len(ar.Repos) == 0 && ar.Why == "" && ar.AC == "" {
+		if ar.Title == "" && ar.Goal == "" && len(ar.Repos) == 0 && ar.Why == "" && ar.AC == "" && len(ar.stepsList()) == 0 {
 			return fmt.Errorf("phase=propose, но нет ни одного изменённого поля")
 		}
 	case "ready":
@@ -195,3 +257,63 @@ func validateResponse(ar *AnalystResponse) error {
 	}
 	return nil
 }
+
+// formatVerdict собирает человекочитаемое однострочное описание вердикта
+// аналитика (без JSON-разметки) для панели «Логи».
+func formatVerdict(ar *AnalystResponse) string {
+	var b strings.Builder
+	b.WriteString("phase=" + ar.Phase)
+
+	if ar.ChatReply != "" {
+		b.WriteString(", chat_reply=")
+		b.WriteString(ar.ChatReply)
+	}
+	if len(ar.Questions) > 0 {
+		b.WriteString(", questions=[")
+		b.WriteString(strings.Join(ar.Questions, " | "))
+		b.WriteString("]")
+	}
+	if ar.Title != "" {
+		b.WriteString(", title=")
+		b.WriteString(ar.Title)
+	}
+	if ar.Goal != "" {
+		b.WriteString(", goal=")
+		b.WriteString(ar.Goal)
+	}
+	if ar.Repo != "" {
+		b.WriteString(", repo=")
+		b.WriteString(ar.Repo)
+	}
+	if repos := ar.reposList(); len(repos) > 0 {
+		b.WriteString(", repos=[")
+		b.WriteString(strings.Join(repos, ", "))
+		b.WriteString("]")
+	}
+	if ar.Why != "" {
+		b.WriteString(", why=")
+		b.WriteString(ar.Why)
+	}
+	if ar.AC != "" {
+		b.WriteString(", ac=")
+		b.WriteString(ar.AC)
+	}
+	if steps := ar.stepsList(); len(steps) > 0 {
+		b.WriteString(", steps=[")
+		var parts []string
+		for _, st := range steps {
+			s := st.Title
+			if st.AC != "" {
+				s += " → " + st.AC
+			}
+			parts = append(parts, s)
+		}
+		b.WriteString(strings.Join(parts, " | "))
+		b.WriteString("]")
+	}
+	if ar.AbortReason != "" {
+		b.WriteString(", abort_reason=")
+		b.WriteString(ar.AbortReason)
+	}
+	return b.String()
+}

internal/analyst/analyst_test.go

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

internal/analyst/prompt.go

@@ -3,6 +3,8 @@ package analyst
 import (
 	"strings"
 	"text/template"
+
+	"github.com/kamelion/ratatoskr-go/internal/storage"
 )
 
 // promptTemplate — шаблон промпта для аналитика (opencode analyst-agent).
@@ -23,6 +25,7 @@ var promptTemplate = template.Must(template.New("analyst").Parse(`Ты — ан
 | repos | список репозиториев (имена на git-хосте; для связанных — все сразу) |
 | why | зачем это нужно, контекст |
 | ac | acceptance criteria — конкретный результат, что считается готовым |
+| steps | (опционально) разбиение задачи на этапы: список {title, ac} с критерием готовности каждого этапа |
 
 Изменяй в JSON только те поля, которые надо поменять; что менять не надо — пустой строкой.
 
@@ -51,6 +54,12 @@ var promptTemplate = template.Must(template.New("analyst").Parse(`Ты — ан
 {{- else}}  repos: (не задано){{end}}
 {{if .Why}}  why: {{.Why}}{{else}}  why: (не задано){{end}}
 {{if .AC}}  ac: {{.AC}}{{else}}  ac: (не задано){{end}}
+{{if .Steps}}
+  steps:
+{{- range .Steps}}
+    - {{.Title}}{{if .AC}} → {{.AC}}{{end}}
+{{- end}}
+{{- else}}  steps: (не задано){{end}}
 
 **Ответь строго JSON-объектом, без лишнего текста:**
 {
@@ -60,6 +69,7 @@ var promptTemplate = template.Must(template.New("analyst").Parse(`Ты — ан
   "repos": ["имя_репо_1", "имя_репо_2"],
   "why": "зачем (только если меняешь)",
   "ac": "критерии (только если меняешь)",
+  "steps": [{"title": "этап 1", "ac": "критерий этапа 1"}],
   "questions": ["вопрос 1", "вопрос 2"],
   "chat_reply": "твой ответ пользователю (на русском, естественно)",
   "abort_reason": "если phase=abort — причина"
@@ -73,6 +83,7 @@ type TemplateData struct {
 	Repos   []string
 	Why     string
 	AC      string
+	Steps   []storage.Step
 	History string // отформатированная переписка
 	Force   bool
 }

internal/app/app.go

@@ -11,6 +11,7 @@ import (
 	"os/signal"
 	"path/filepath"
 	"strings"
+	"sync"
 	"syscall"
 	"time"
 
@@ -52,7 +53,7 @@ const packageOwner = "kamelion"
 // не следует путать с build-идентификатором `main.version` (commit-<sha7>),
 // который вшивается ldflag'ом и используется автообновлением. Здесь номер
 // поднимается вручную перед каждым релизом/публикацией новой сборки.
-const Version = "0.2.2"
+const Version = "0.3.0"
 
 // App — собранный конвейер.
 type App struct {
@@ -62,7 +63,7 @@ type App struct {
 	CoreCtx *core.Core
 	Worker  *worker.Worker
 	Updater *update.Updater
-	tg      *telegram.Channel // сохранена для Run
+	tg      *telegram.Channel // сохранена для Run (nil, если telegram.enabled=false)
 	pool    *opencode.Pool    // пул opencode serve-серверов (API-режим)
 
 	// Events — доменная шина UI; LogEvents — шина логов (панель «Логи»).
@@ -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
 }
 
@@ -148,8 +156,6 @@ func New(configPath, version, updateToken string, noUI bool) (*App, error) {
 	// Служебный root-сервер (worktree) живёт всё время app; остальные лениво.
 	ocPool := opencode.NewPool(cfg.Paths.Worktree)
 	ocPool.Bin = cfg.OpenCode.Bin
-	ocPool.Config = cfg.OpenCode.Config
-	ocPool.ConfigDir = cfg.OpenCode.ConfigDir
 	ocPool.DBPath = cfg.OpenCode.DBPath
 	ocPool.Host = cfg.OpenCode.Serve.Hostname
 	ocPool.BasePort = cfg.OpenCode.Serve.Port
@@ -216,13 +222,15 @@ func New(configPath, version, updateToken string, noUI bool) (*App, error) {
 		}
 	}
 
-	// Telegram-канал
+	// Telegram-канал (если включён; иначе сетевые вызовы к Telegram не идут)
+	if cfg.Telegram.Enabled {
 		tg := telegram.New(cfg.Telegram.Token, cfg.Chat.PollInterval.Duration())
 		a.tg = tg
 		if err := router.Attach(tg); err != nil {
 			store.Close()
 			return nil, fmt.Errorf("attach telegram: %w", err)
 		}
+	}
 
 	// Worker — polling-планировщик dev-агента
 	w := &worker.Worker{
@@ -283,15 +291,15 @@ func (a *App) Run(ctx context.Context) error {
 	}
 	defer a.pool.Close()
 
-	// Канал для проверки Telegram-ошибки (горутина оборачивает Run)
+	// Telegram: long-poll цикл в горутине (только если канал включён)
 	tgErr := make(chan error, 1)
-
-	// Telegram: long-poll цикл в горутине
+	if a.telegramChannel() != nil {
 		go func() {
 			tg := a.telegramChannel()
 			log.Print("app: telegram poll started")
 			tgErr <- tg.Run(ctx)
 		}()
+	}
 
 	// Worker: poll-цикл (неблокирующий — стартует свою горутину)
 	a.Worker.Start(ctx)
@@ -312,6 +320,7 @@ func (a *App) Run(ctx context.Context) error {
 	sigCh := make(chan os.Signal, 1)
 	signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
 
+	if a.telegramChannel() != nil {
 		select {
 		case <-ctx.Done():
 			log.Print("app: context cancelled")
@@ -326,6 +335,17 @@ func (a *App) Run(ctx context.Context) error {
 			}
 			return nil
 		}
+	}
+
+	select {
+	case <-ctx.Done():
+		log.Print("app: context cancelled")
+		return nil
+	case sig := <-sigCh:
+		log.Printf("app: signal %s — shutting down", sig)
+		cancel()
+		return nil
+	}
 }
 
 // telegramChannel возвращает Telegram-канал.
@@ -643,23 +663,21 @@ func (a *App) handleUpdateCmd(ctx context.Context, uid chat.UserID) {
 	// сюда не возвращаемся — SwapAndRestart завершил процесс (os.Exit)
 }
 
-// ensureAgentsDir определяет каталог с агентами opencode и распаковывает
-// туда встроенных агентов (go:embed). Если config_dir не задан — использует
-// ./agents рядом с бинарём. Встроенные агенты перезаписываются (всегда актуальны).
+// ensureAgentsDir распаковывает встроенных агентов opencode (go:embed) в
+// project-каталог <worktree>/.opencode/agent/*.md. opencode при serve (cwd =
+// worktree) обнаруживает .opencode поднятием вверх (paths.ts) и сам находит
+// агентов. Глобальный конфиг opencode (модель/провайдеры) не трогаем и
+// OPENCODE_CONFIG_DIR не выставляем.
 //
 // idempotent: вызывается только из New.
 func ensureAgentsDir(cfg *config.Config) error {
-	if cfg.OpenCode.ConfigDir == "" {
-		exe, err := os.Executable()
-		if err != nil {
-			return fmt.Errorf("resolve executable: %w", err)
+	if cfg.Paths.Worktree == "" {
+		return fmt.Errorf("paths.worktree не задан — некуда раскладывать агентов")
 	}
-		// ./agents рядом с бинарём
-		cfg.OpenCode.ConfigDir = filepath.Join(filepath.Dir(exe), "agents")
+	base := filepath.Join(cfg.Paths.Worktree, ".opencode")
+	if err := agents.WriteTo(base); err != nil {
+		return fmt.Errorf("write agents to %s: %w", base, err)
 	}
-	if err := agents.WriteTo(cfg.OpenCode.ConfigDir); err != nil {
-		return fmt.Errorf("write agents to %s: %w", cfg.OpenCode.ConfigDir, err)
-	}
-	log.Printf("app: agents ensured in %s", cfg.OpenCode.ConfigDir)
+	log.Printf("app: agents ensured in %s", base)
 	return 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/config/config_test.go

@@ -146,54 +146,6 @@ log:
 	}
 }
 
-func TestLoad_OpenCodeConfigDir(t *testing.T) {
-	t.Setenv("TG_TOKEN", "tok")
-	t.Setenv("TG_CHAT_ID", "42")
-
-	// без config_dir — пусто
-	yaml := `telegram:
-  token: "${TG_TOKEN}"
-  chat_id: "${TG_CHAT_ID}"
-`
-	cfg, err := Load(writeCfg(t, yaml))
-	if err != nil {
-		t.Fatalf("Load: %v", err)
-	}
-	if cfg.OpenCode.ConfigDir != "" {
-		t.Errorf("config_dir = %q, want пусто", cfg.OpenCode.ConfigDir)
-	}
-
-	// через env OPENCODE_CONFIG_DIR
-	t.Setenv("OPENCODE_CONFIG_DIR", "/opt/agents")
-	cfg, err = Load(writeCfg(t, yaml))
-	if err != nil {
-		t.Fatalf("Load: %v", err)
-	}
-	if cfg.OpenCode.ConfigDir != "/opt/agents" {
-		t.Errorf("config_dir = %q, want /opt/agents", cfg.OpenCode.ConfigDir)
-	}
-}
-
-func TestLoad_EnvOverride(t *testing.T) {
-	t.Setenv("TG_TOKEN", "tok")
-	t.Setenv("TG_CHAT_ID", "42")
-	// env override для opencode.timeout
-	t.Setenv("OPENCODE_CONFIG", "/custom/opencode.json")
-
-	yaml := `telegram:
-  token: "${TG_TOKEN}"
-  chat_id: "${TG_CHAT_ID}"
-`
-	path := writeCfg(t, yaml)
-	cfg, err := Load(path)
-	if err != nil {
-		t.Fatalf("Load: %v", err)
-	}
-	if cfg.OpenCode.Config != "/custom/opencode.json" {
-		t.Errorf("opencode config = %q", cfg.OpenCode.Config)
-	}
-}
-
 func TestLoad_MissingEnvVarUsesDefault(t *testing.T) {
 	t.Setenv("TG_TOKEN", "tok")
 	t.Setenv("TG_CHAT_ID", "42")
@@ -277,7 +229,7 @@ paths:
 }
 
 func TestLoad_MissingRequired(t *testing.T) {
-	// пустой конфиг — все обязательные поля отсутствуют
+	// пустой конфиг — все обязательные поля отсутствуют (telegram.enabled по дефолту true)
 	t.Setenv("TG_TOKEN", "")
 	t.Setenv("TG_CHAT_ID", "")
 
@@ -298,6 +250,41 @@ func TestLoad_MissingRequired(t *testing.T) {
 	}
 }
 
+func TestLoad_TelegramDisabledSkipsToken(t *testing.T) {
+	// enabled: false — token/chat_id не обязательны, конфиг валиден
+	t.Setenv("TG_TOKEN", "")
+	t.Setenv("TG_CHAT_ID", "")
+
+	yaml := `telegram:
+  enabled: false
+  token: ""
+  chat_id: ""
+`
+	path := writeCfg(t, yaml)
+	cfg, err := Load(path)
+	if err != nil {
+		t.Fatalf("Load: %v", err)
+	}
+	if cfg.Telegram.Enabled {
+		t.Error("telegram.enabled = true, want false")
+	}
+}
+
+func TestLoad_TelegramEnabledDefaultTrue(t *testing.T) {
+	// enabled не задан — дефолт true, token обязателен
+	t.Setenv("TG_TOKEN", "")
+	t.Setenv("TG_CHAT_ID", "42")
+
+	yaml := `telegram:
+  chat_id: "42"
+`
+	path := writeCfg(t, yaml)
+	_, err := Load(path)
+	if err == nil || !strings.Contains(err.Error(), "telegram.token") {
+		t.Errorf("ожидалась ошибка telegram.token (enabled по дефолту true), got %v", err)
+	}
+}
+
 func TestLoad_InvalidDuration(t *testing.T) {
 	t.Setenv("TG_TOKEN", "x")
 	t.Setenv("TG_CHAT_ID", "x")

internal/config/load.go

@@ -35,6 +35,10 @@ func Load(path string) (*Config, error) {
 		}
 	}
 	cfg := &Config{}
+	// Telegram по умолчанию включён (если в YAML не указан enabled).
+	// Делаем до unmarshal: yaml.Unmarshal перезапишет поле, только если ключ
+	// есть в документе, поэтому отсутствующий enabled останется true.
+	cfg.Telegram.Enabled = true
 	if !noFile {
 		expanded := os.Expand(string(raw), envLookup)
 		if err := yaml.Unmarshal([]byte(expanded), cfg); err != nil {

internal/config/types.go

@@ -76,7 +76,11 @@ type UpdateCfg struct {
 	CheckInterval Duration `yaml:"check_interval" default:"24h"`
 }
 
+// TelegramCfg — настройки Telegram-канала. Enabled=false отключает канал
+// полностью: бот не опрашивается, сетевые вызовы к api.telegram.org не идут,
+// token/chat_id не обязательны. По умолчанию включён (см. Load: presetTelegramEnabled).
 type TelegramCfg struct {
+	Enabled bool   `yaml:"enabled"`
 	Token   string `yaml:"token"    env:"TG_TOKEN"`
 	ChatID  string `yaml:"chat_id"  env:"TG_CHAT_ID"`
 }
@@ -84,8 +88,6 @@ type TelegramCfg struct {
 type OpenCodeCfg struct {
 	Bin         string   `yaml:"bin"           default:"opencode"`
 	DBPath      string   `yaml:"db_path"       default:""`
-	Config      string   `yaml:"config"        env:"OPENCODE_CONFIG"`
-	ConfigDir   string   `yaml:"config_dir"    env:"OPENCODE_CONFIG_DIR"`
 	HardTimeout Duration `yaml:"hard_timeout"   default:"20m"`
 	IdleTimeout Duration `yaml:"idle_timeout"   default:"5m"`
 	PollMs      Duration `yaml:"poll_ms"        default:"2s"`
@@ -121,12 +123,14 @@ type PathsCfg struct {
 // (склеенную, все ошибки сразу) или C2 InvalidFormat.
 func (c *Config) Validate() error {
 	var errs []error
+	if c.Telegram.Enabled {
 		if c.Telegram.Token == "" {
 			errs = append(errs, fmt.Errorf("%w: telegram.token", ErrMissingField))
 		}
 		if c.Telegram.ChatID == "" {
 			errs = append(errs, fmt.Errorf("%w: telegram.chat_id", ErrMissingField))
 		}
+	}
 	if !c.Log.Debug() && !strings.EqualFold(c.Log.Level, "info") {
 		errs = append(errs, fmt.Errorf("%w: log.level (ожидается \"info\" или \"debug\")", ErrInvalidFormat))
 	}

internal/core/core.go

@@ -228,6 +228,11 @@ func (c *Core) handleRetry(ctx context.Context, rest string) (Result, error) {
 	if err := c.Store.ClearHistory(ctx, id); err != nil {
 		return Result{}, err
 	}
+	// Чистый перезапуск: сбрасываем маркер постмортем-анализа от прошлого
+	// прогона, чтобы на новом failed/timeout постмортем запустился заново.
+	if err := c.Store.DeleteTracesByAgent(ctx, id, "postmortem"); err != nil {
+		return Result{}, err
+	}
 	return Result{
 		Reply:  "Задача перезапущена. Опишите, что меняем:",
 		TaskID: id,

internal/events/log_test.go

@@ -85,6 +85,8 @@ func TestClassifyLevel(t *testing.T) {
 		{"app: db opened /tmp/r.db", LevelInfo},
 		{"app: worker started", LevelInfo},
 		{"opencode: debug: poll request", LevelDebug},
+		{"opencode api debug: prompt -> POST http://127.0.0.1:4096/api/session", LevelDebug},
+		{"opencode api debug: messages response (512 bytes)", LevelDebug},
 		{"trace: session resumed", LevelDebug},
 		{"tg: warn: long poll timeout", LevelWarning},
 		{"ПРЕДУПРЕЖДЕНИЕ: конфиг не задан", LevelWarning},

internal/opencode/client.go

@@ -6,8 +6,8 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
-	"log"
 	"net/http"
+	"strings"
 	"time"
 )
 
@@ -26,10 +26,18 @@ import (
 type Client struct {
 	BaseURL   string       // http://host:port (без завершающего слеша)
 	Password  string       // basic auth (username "opencode")
+	Directory string       // каталог сервера — идёт заголовком x-opencode-directory
 	Debug     bool         // включать отладочные логи API-вызовов (log.level=debug)
 	http      *http.Client // единый клиент: все операции быстрые (нет блокирующего Send)
 }
 
+// SessionMessagesURL возвращает URL для просмотра сообщений сессии в браузере.
+// Сортировка по времени: сначала новые (order=desc). Без credentials — пароль
+// в лог не попадает.
+func SessionMessagesURL(baseURL, sessionID string) string {
+	return baseURL + "/api/session/" + sessionID + "/message?order=desc"
+}
+
 // ClientErr — классы ошибок клиента.
 type ClientErr struct {
 	Op  string // "connect" | "create" | "prompt" | "messages" | "active" | "abort"
@@ -56,17 +64,15 @@ func (c *Client) do(ctx context.Context, method, path, op string, body []byte) (
 	if err != nil {
 		return nil, &ClientErr{Op: "connect", Err: err}
 	}
+	if body != nil {
+		req.ContentLength = int64(len(body))
+	}
 	if c.Password != "" {
 		req.SetBasicAuth("opencode", c.Password)
 	}
-	if body != nil {
 	req.Header.Set("Content-Type", "application/json")
-	}
-	if c.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))
-		}
+	if c.Directory != "" {
+		req.Header.Set("x-opencode-directory", c.Directory)
 	}
 	resp, err := c.http.Do(req)
 	if err != nil {
@@ -78,14 +84,8 @@ func (c *Client) do(ctx context.Context, method, path, op string, body []byte) (
 		return nil, &ClientErr{Op: "connect", Err: err}
 	}
 	if resp.StatusCode < 200 || resp.StatusCode > 299 {
-		if c.Debug {
-			log.Printf("opencode api %s response: status %d: %s", op, resp.StatusCode, truncateStr(string(b), 1000))
-		}
 		return nil, &ClientErr{Op: op, Err: fmt.Errorf("status %d: %s", resp.StatusCode, truncateStr(string(b), 300))}
 	}
-	if c.Debug {
-		log.Printf("opencode api %s response (%d bytes): %s", op, len(b), truncateStr(string(b), 5000))
-	}
 	return b, nil
 }
 
@@ -97,7 +97,7 @@ type ModelRef struct {
 	Variant    string `json:"variant,omitempty"`
 }
 
-// String возвращает каноничное представление "provider/id[/variant]".
+// String возвращает каноническое представление "provider/id[/variant]".
 func (m *ModelRef) String() string {
 	if m == nil {
 		return ""
@@ -108,13 +108,14 @@ func (m *ModelRef) String() string {
 	return m.ProviderID + "/" + m.ID
 }
 
-// CreateSession создаёт новую сессию и возвращает её id. model != nil —
-// хардпин модели (top-level "model" из конфига opencode), чтобы не зависеть
-// от fallback-логики выбора модели в самом opencode.
-func (c *Client) CreateSession(ctx context.Context, model *ModelRef) (string, error) {
+// CreateSession создаёт новую сессию и возвращает её id. agent — имя агента
+// (analyst/dev/reviewer/chat/postmortem) из встроенных определений ratatoskr.
+// Модель мы НЕ выбираем: opencode сам берёт модель по умолчанию из своего
+// глобального конфига (ratatoskr про неё ничего не знает).
+func (c *Client) CreateSession(ctx context.Context, agent string) (string, error) {
 	payload := map[string]any{}
-	if model != nil {
-		payload["model"] = model
+	if agent != "" {
+		payload["agent"] = agent
 	}
 	body, _ := json.Marshal(payload)
 	raw, err := c.do(ctx, http.MethodPost, "/api/session", "create", body)
@@ -132,6 +133,12 @@ func (c *Client) CreateSession(ctx context.Context, model *ModelRef) (string, er
 	if out.Data.ID == "" {
 		return "", &ClientErr{Op: "create", Err: fmt.Errorf("пустой id сессии")}
 	}
+	time.Sleep(2 * time.Second)
+	// Холостой вызов /api/model: прогревает сервер (модель/провайдеры),
+	// чтобы первый промпт не спотыкался о «тёплый» старт.
+	_, _ = c.do(ctx, http.MethodGet, "/api/model", "models-warmup", nil)
+	time.Sleep(2 * time.Second)
+	_, _ = c.do(ctx, http.MethodGet, "/api/model", "models-warmup", nil)
 	return out.Data.ID, nil
 }
 
@@ -323,6 +330,79 @@ func assistantText(msgs []v2Message, since int64) []string {
 	return texts
 }
 
+// assistantVerdict собирает финальный текст ответа: сначала text-парты, а если
+// их нет — только reasoning-парты (fallback для моделей, которые на некоторые
+// запросы отвечают лишь reasoning без text). usedReasoning=true означает, что
+// text-партов не было вовсе и вердикт собран из reasoning.
+func assistantVerdict(msgs []v2Message, since int64) (texts []string, usedReasoning bool) {
+	if texts := assistantText(msgs, since); len(texts) > 0 {
+		return texts, false
+	}
+	ass := assistantSince(msgs, since)
+	reasoning := make([]string, 0, len(ass))
+	for i := len(ass) - 1; i >= 0; i-- {
+		for _, p := range ass[i].Content {
+			if p.Type == "reasoning" && p.Text != "" {
+				reasoning = append(reasoning, p.Text)
+			}
+		}
+	}
+	return reasoning, len(reasoning) > 0
+}
+
+// transcriptRole возвращает человекочитаемую подпись роли сообщения сессии.
+func transcriptRole(t string) string {
+	switch t {
+	case "user":
+		return "Пользователь"
+	case "assistant":
+		return "Ассистент"
+	case "tool":
+		return "Инструмент"
+	case "system":
+		return "Система"
+	default:
+		return t
+	}
+}
+
+// finishLabel — подпись для finish-reason (пусто/: опускаем).
+func finishLabel(f string) string {
+	if f == "" || f == "stop" {
+		return ""
+	}
+	return f
+}
+
+// renderTranscript форматирует сообщения сессии (API отдаёт новыми первыми)
+// в хронологическом порядке: роль, текст (и tool-вызовы), с обрезкой.
+func renderTranscript(msgs []v2Message) string {
+	var b strings.Builder
+	for i := len(msgs) - 1; i >= 0; i-- {
+		m := &msgs[i]
+		b.WriteString("\n== " + transcriptRole(m.Type))
+		if m.Type == "assistant" {
+			if m.Model != nil {
+				b.WriteString(" (" + m.Model.String() + ")")
+			}
+			if fl := finishLabel(m.Finish); fl != "" {
+				b.WriteString(" finish=" + fl)
+			}
+		}
+		b.WriteString(" ==\n")
+		for _, p := range m.Content {
+			if p.Text == "" {
+				continue
+			}
+			b.WriteString(p.Text)
+			if !strings.HasSuffix(p.Text, "\n") {
+				b.WriteString("\n")
+			}
+		}
+	}
+	return b.String()
+}
+
 func truncateStr(s string, n int) string {
 	if len(s) <= n {
 		return s

internal/opencode/client_test.go

@@ -28,9 +28,10 @@ type fakeAPIServer struct {
 	blockPrompt  bool
 	messages     []v2Message
 	verdictText  string
+	verdictReasoning string // завершённый ответ только с reasoning-партом (без text)
 	failCreate   bool
 	failMessages bool
-	createdModel *ModelRef // модель, полученная на POST /api/session
+	createdAgent string // агент, полученный на POST /api/session
 	promptCalls int
 
 	// streamGrow: стрим одного растущего парта — текст/reasoning растёт с
@@ -54,10 +55,10 @@ func (f *fakeAPIServer) handler() http.Handler {
 			return
 		}
 		var in struct {
-			Model *ModelRef `json:"model"`
+			Agent string `json:"agent"`
 		}
 		_ = json.NewDecoder(r.Body).Decode(&in)
-		f.createdModel = in.Model
+		f.createdAgent = in.Agent
 		f.sessionID = "sess-fake"
 		f.created = true
 		writeJSON(w, map[string]any{"data": map[string]any{"id": "sess-fake"}})
@@ -133,6 +134,9 @@ func (f *fakeAPIServer) handler() http.Handler {
 		if msgs == nil && f.verdictText != "" && !f.blockPrompt {
 			msgs = []v2Message{f.assistantMsg(f.verdictText)}
 		}
+		if msgs == nil && f.verdictReasoning != "" && !f.blockPrompt {
+			msgs = []v2Message{f.assistantReasoningMsg(f.verdictReasoning)}
+		}
 		if msgs == nil {
 			msgs = []v2Message{}
 		}
@@ -153,6 +157,19 @@ func (f *fakeAPIServer) assistantMsg(text string) v2Message {
 	}
 }
 
+// assistantReasoningMsg строит завершённое assistant-сообщение только с
+// reasoning-партом (без text) — для проверки fallback-сценария.
+func (f *fakeAPIServer) assistantReasoningMsg(text string) v2Message {
+	now := time.Now().UnixMilli()
+	return v2Message{
+		ID:      "msg_r",
+		Type:    "assistant",
+		Content: []v2Part{{Type: "reasoning", Text: text}},
+		Finish:  "end_turn",
+		Time:    v2Time{Created: &now, Completed: &now},
+	}
+}
+
 func writeJSON(w http.ResponseWriter, v any) {
 	w.Header().Set("Content-Type", "application/json")
 	_ = json.NewEncoder(w).Encode(v)
@@ -169,33 +186,43 @@ func fakeClient(t *testing.T, f *fakeAPIServer) *Client {
 func TestClient_CreateSession(t *testing.T) {
 	f := &fakeAPIServer{}
 	c := fakeClient(t, f)
-	id, err := c.CreateSession(context.Background(), nil)
+	id, err := c.CreateSession(context.Background(), "dev")
 	if err != nil {
 		t.Fatalf("CreateSession err: %v", err)
 	}
 	if id != "sess-fake" {
 		t.Errorf("id = %q, want sess-fake", id)
 	}
-	if f.createdModel != nil {
-		t.Errorf("createdModel = %+v, want nil", f.createdModel)
+	if f.createdAgent != "dev" {
+		t.Errorf("createdAgent = %q, want dev", f.createdAgent)
 	}
 }
 
-func TestClient_CreateSessionHardpinsModel(t *testing.T) {
-	want := &ModelRef{ProviderID: "tokentool", ID: "deepseek/deepseek-v4-flash-0731"}
+func TestClient_CreateSessionPassesAgent(t *testing.T) {
 	f := &fakeAPIServer{}
 	c := fakeClient(t, f)
-	if _, err := c.CreateSession(context.Background(), want); err != nil {
+	if _, err := c.CreateSession(context.Background(), "postmortem"); err != nil {
 		t.Fatalf("CreateSession err: %v", err)
 	}
-	if f.createdModel == nil || f.createdModel.ProviderID != want.ProviderID || f.createdModel.ID != want.ID {
-		t.Errorf("createdModel = %+v, want %+v", f.createdModel, want)
+	if f.createdAgent != "postmortem" {
+		t.Errorf("createdAgent = %q, want postmortem", f.createdAgent)
+	}
+}
+
+func TestClient_CreateSessionNoAgent(t *testing.T) {
+	f := &fakeAPIServer{}
+	c := fakeClient(t, f)
+	if _, err := c.CreateSession(context.Background(), ""); err != nil {
+		t.Fatalf("CreateSession err: %v", err)
+	}
+	if f.createdAgent != "" {
+		t.Errorf("createdAgent = %q, want пусто", f.createdAgent)
 	}
 }
 
 func TestClient_CreateSessionFail(t *testing.T) {
 	c := fakeClient(t, &fakeAPIServer{failCreate: true})
-	if _, err := c.CreateSession(context.Background(), nil); err == nil {
+	if _, err := c.CreateSession(context.Background(), "dev"); err == nil {
 		t.Fatal("CreateSession должен упасть при 500, а не nil")
 	}
 }
@@ -279,16 +306,45 @@ func Test_newestAssistant(t *testing.T) {
 	}
 }
 
-func Test_parseModelString(t *testing.T) {
-	m := parseModelString("tokentool/deepseek/deepseek-v4-flash-0731")
-	if m == nil || m.ProviderID != "tokentool" || m.ID != "deepseek/deepseek-v4-flash-0731" {
-		t.Errorf("parse = %+v, want tokentool/deepseek-v4-flash-0731", m)
+func Test_assistantVerdict(t *testing.T) {
+	older := time.Now().Add(-time.Minute).UnixMilli()
+	newer := time.Now().UnixMilli()
+	reasoningOf := func(text string, at *int64) v2Message {
+		return v2Message{ID: "r", Type: "assistant", Content: []v2Part{{Type: "reasoning", Text: text}}, Time: v2Time{Created: at}}
 	}
-	if parseModelString("onlyprovider") != nil {
-		t.Error("parse без '/' должен вернуть nil")
+
+	// reasoning-only: text-партов нет → fallback на reasoning, usedReasoning=true.
+	// Сообщения приходят новейшими первыми (как из API) → размышление 2 новее.
+	reasoningOnlyMsgs := []v2Message{
+		reasoningOf("размышление 2", &newer),
+		reasoningOf("размышление 1", &older),
 	}
-	if parseModelString("") != nil {
-		t.Error("parse пустой должен вернуть nil")
+	texts, used := assistantVerdict(reasoningOnlyMsgs, older)
+	if !used {
+		t.Error("usedReasoning = false, want true для reasoning-only")
+	}
+	if len(texts) != 2 || texts[0] != "размышление 1" || texts[1] != "размышление 2" {
+		t.Errorf("verdict = %v, want [размышление 1 размышление 2] (хронологически)", texts)
+	}
+
+	// text + reasoning → берётся text, reasoning игнорируется.
+	mixed := []v2Message{
+		{ID: "a", Type: "assistant",
+			Content: []v2Part{{Type: "reasoning", Text: "thinking"}, {Type: "text", Text: "ответ"}},
+			Time:     v2Time{Created: &newer}},
+	}
+	texts, used = assistantVerdict(mixed, older)
+	if used {
+		t.Error("usedReasoning = true, want false (есть text)")
+	}
+	if len(texts) != 1 || texts[0] != "ответ" {
+		t.Errorf("verdict = %v, want [ответ]", texts)
+	}
+
+	// пусто → пусто и usedReasoning=false.
+	empty := []v2Message{{ID: "u", Type: "user", Time: v2Time{Created: &newer}}}
+	if texts, used := assistantVerdict(empty, older); used || len(texts) != 0 {
+		t.Errorf("пусто: texts=%v usedReasoning=%v, want пусто/false", texts, used)
 	}
 }
 
@@ -299,3 +355,12 @@ func TestClientErr_Unwrap(t *testing.T) {
 		t.Fatal("expected *ClientErr")
 	}
 }
+
+// TestSessionMessagesURL — ссылка на сообщения сессии, сортировка по времени (новые сверху).
+func TestSessionMessagesURL(t *testing.T) {
+	got := SessionMessagesURL("http://127.0.0.1:4101", "sess-abc")
+	want := "http://127.0.0.1:4101/api/session/sess-abc/message?order=desc"
+	if got != want {
+		t.Errorf("SessionMessagesURL() = %q, want %q", got, want)
+	}
+}

internal/opencode/config.go

@@ -1,176 +0,0 @@
-package opencode
-
-import (
-	"encoding/json"
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-)
-
-// Чтение top-level "model" из эффективного конфига opencode.
-//
-// Зачем: ratatoskr хардпинит модель в сессии (CreateSession), чтобы не зависеть
-// от fallback-логики opencode. Если в конфиге модель не задана (или конфиг
-// написан по старой v1-схеме — npm/options, которые v2 молча игнорирует),
-// opencode сам выберет «дефолтную» модельную запись, и это может оказаться не
-// той моделью. Поэтому мы явно логируем предупреждение (класс O5 WARN).
-
-// opencodeConfigPath определяет путь к конфигу opencode, который видит
-// serve-процесс этого пула (см. README): (1) явный OPENCODE_CONFIG из Server
-// или окружения процесса, (2) OPENCODE_CONFIG_DIR / глобальный каталог
-// ~/.config/opencode. Возвращает "" если ничего не найдено.
-func opencodeConfigPath(cfgFile, cfgDir string) string {
-	// (1) явный файл конфига — Server.Config или env OPENCODE_CONFIG.
-	p := cfgFile
-	if p == "" {
-		p = os.Getenv("OPENCODE_CONFIG")
-	}
-	if p != "" {
-		if st, err := os.Stat(p); err == nil && !st.IsDir() {
-			return p
-		}
-	}
-	// (2) каталог конфигов.
-	dir := cfgDir
-	if dir == "" {
-		dir = os.Getenv("OPENCODE_CONFIG_DIR")
-	}
-	if dir == "" {
-		home, err := os.UserHomeDir()
-		if err != nil || home == "" {
-			return ""
-		}
-		dir = filepath.Join(home, ".config", "opencode")
-		if x := os.Getenv("XDG_CONFIG_HOME"); x != "" {
-			dir = filepath.Join(x, "opencode")
-		}
-	}
-	for _, name := range []string{"opencode.json", "opencode.jsonc"} {
-		cand := filepath.Join(dir, name)
-		if st, err := os.Stat(cand); err == nil && !st.IsDir() {
-			return cand
-		}
-	}
-	return ""
-}
-
-// ReadModelRef извлекает top-level "model" из конфига opencode и возвращает
-// его как ModelRef. Модель не задана — вернёт (nil, nil); ошибка чтения/парсинга
-// возвращается (вызывающий логирует warning и продолжает без хардпина).
-func ReadModelRef(cfgFile, cfgDir string) (*ModelRef, error) {
-	path := opencodeConfigPath(cfgFile, cfgDir)
-	if path == "" {
-		return nil, nil
-	}
-	b, err := os.ReadFile(path)
-	if err != nil {
-		return nil, fmt.Errorf("config: читать %s: %w", path, err)
-	}
-	doc := struct {
-		Model json.RawMessage `json:"model"`
-	}{}
-	if err := json.Unmarshal(stripJSONC(b), &doc); err != nil {
-		return nil, fmt.Errorf("config: парсить %s: %w", path, err)
-	}
-	if len(doc.Model) == 0 || strings.TrimSpace(string(doc.Model)) == "null" {
-		return nil, nil
-	}
-	// "model" может быть строкой "provider/id" или объектом {providerID, id}.
-	var s string
-	if err := json.Unmarshal(doc.Model, &s); err == nil {
-		ref := parseModelString(s)
-		if ref == nil {
-			return nil, fmt.Errorf("config: некорректная model %q в %s (ожидается provider/id)", s, path)
-		}
-		return ref, nil
-	}
-	var ref ModelRef
-	if err := json.Unmarshal(doc.Model, &ref); err != nil {
-		return nil, fmt.Errorf("config: некорректная model в %s", path)
-	}
-	if ref.ProviderID == "" || ref.ID == "" {
-		return nil, fmt.Errorf("config: model без providerID/id в %s", path)
-	}
-	return &ref, nil
-}
-
-// parseModelString разбирает "provider/id" (как ModelV2.parse: провайдер — всё
-// до первого '/', id — остаток). Возвращает nil при пустой/некорректной строке.
-func parseModelString(s string) *ModelRef {
-	s = strings.TrimSpace(s)
-	if s == "" {
-		return nil
-	}
-	i := strings.IndexByte(s, '/')
-	if i <= 0 || i == len(s)-1 {
-		return nil
-	}
-	return &ModelRef{ProviderID: s[:i], ID: s[i+1:]}
-}
-
-// stripJSONC удаляет // и /* */ комментарии (вне строк), сохраняя позиции
-// переводов строк, чтобы json.Unmarshal не споткнулся о trailing-комма.
-func stripJSONC(b []byte) []byte {
-	out := make([]byte, 0, len(b))
-	inStr := false
-	esc := false
-	i := 0
-	for i < len(b) {
-		c := b[i]
-		if inStr {
-			out = append(out, c)
-			if esc {
-				esc = false
-			} else if c == '\\' {
-				esc = true
-			} else if c == '"' {
-				inStr = false
-			}
-			i++
-			continue
-		}
-		switch {
-		case c == '"':
-			inStr = true
-			out = append(out, c)
-			i++
-		case c == '/' && i+1 < len(b) && b[i+1] == '/':
-			for i < len(b) && b[i] != '\n' {
-				i++
-			}
-			if i < len(b) {
-				out = append(out, '\n')
-				i++
-			}
-		case c == '/' && i+1 < len(b) && b[i+1] == '*':
-			i += 2
-			for i+1 < len(b) && !(b[i] == '*' && b[i+1] == '/') {
-				i++
-			}
-			i += 2
-		default:
-			out = append(out, c)
-			i++
-		}
-	}
-	return dropTrailingCommas(out)
-}
-
-// dropTrailingCommas убирает запятые перед '}' / ']' (допускаются в JSONC).
-func dropTrailingCommas(b []byte) []byte {
-	out := make([]byte, 0, len(b))
-	for i := 0; i < len(b); i++ {
-		if b[i] == ',' {
-			j := i + 1
-			for j < len(b) && (b[j] == ' ' || b[j] == '\t' || b[j] == '\n' || b[j] == '\r') {
-				j++
-			}
-			if j < len(b) && (b[j] == '}' || b[j] == ']') {
-				continue
-			}
-		}
-		out = append(out, b[i])
-	}
-	return out
-}

internal/opencode/config_test.go

@@ -1,85 +0,0 @@
-package opencode
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func TestReadModelRef_String(t *testing.T) {
-	dir := t.TempDir()
-	path := filepath.Join(dir, "opencode.jsonc")
-	// конфиг с комментариями и trailing-запятыми (JSONC).
-	src := `{
-		// комментарий
-		"model": "tokentool/deepseek/deepseek-v4-flash-0731", /* и блочный */
-		"provider": {
-			"tokentool": {"api": {"type": "aisdk", "package": "@ai-sdk/openai-compatible", "url": "https://x"}},
-		},
-	}`
-	if err := os.WriteFile(path, []byte(src), 0o644); err != nil {
-		t.Fatalf("write: %v", err)
-	}
-	m, err := ReadModelRef(path, "")
-	if err != nil {
-		t.Fatalf("ReadModelRef err: %v", err)
-	}
-	if m == nil || m.ProviderID != "tokentool" || m.ID != "deepseek/deepseek-v4-flash-0731" {
-		t.Errorf("model = %+v, want tokentool/deepseek-v4-flash-0731", m)
-	}
-}
-
-func TestReadModelRef_Object(t *testing.T) {
-	dir := t.TempDir()
-	path := filepath.Join(dir, "opencode.json")
-	src := `{"model": {"providerID": "tokentool", "id": "deepseek/deepseek-v4-flash-0731"}}`
-	if err := os.WriteFile(path, []byte(src), 0o644); err != nil {
-		t.Fatalf("write: %v", err)
-	}
-	m, err := ReadModelRef(path, "")
-	if err != nil {
-		t.Fatalf("ReadModelRef err: %v", err)
-	}
-	if m == nil || m.ID != "deepseek/deepseek-v4-flash-0731" {
-		t.Errorf("model = %+v, want object-форма", m)
-	}
-}
-
-func TestReadModelRef_Missing(t *testing.T) {
-	dir := t.TempDir()
-	path := filepath.Join(dir, "opencode.json")
-	src := `{"provider": {}}`
-	if err := os.WriteFile(path, []byte(src), 0o644); err != nil {
-		t.Fatalf("write: %v", err)
-	}
-	m, err := ReadModelRef(path, "")
-	if err != nil {
-		t.Fatalf("ReadModelRef err: %v", err)
-	}
-	if m != nil {
-		t.Errorf("model = %+v, want nil (model не задан)", m)
-	}
-}
-
-func TestReadModelRef_NoFile(t *testing.T) {
-	dir := t.TempDir()
-	m, err := ReadModelRef(filepath.Join(dir, "nope.json"), dir)
-	if err != nil {
-		t.Fatalf("ReadModelRef err: %v", err)
-	}
-	if m != nil {
-		t.Errorf("model = %+v, want nil", m)
-	}
-}
-
-func TestReadModelRef_Bad(t *testing.T) {
-	dir := t.TempDir()
-	path := filepath.Join(dir, "opencode.json")
-	src := `{"model": 12345}`
-	if err := os.WriteFile(path, []byte(src), 0o644); err != nil {
-		t.Fatalf("write: %v", err)
-	}
-	if _, err := ReadModelRef(path, ""); err == nil {
-		t.Error("ReadModelRef должен упасть на некорректной model")
-	}
-}

internal/opencode/pool.go

@@ -19,8 +19,6 @@ import (
 // директории → каждая сессия API привязана к правильному project-каталогу.
 type Pool struct {
 	Bin       string
-	Config    string
-	ConfigDir string
 	DBPath    string
 	Host      string
 	BasePort  int
@@ -73,8 +71,6 @@ func (p *Pool) EnsureRoot(ctx context.Context) error {
 	}
 	s := &Server{
 		Bin:      p.Bin,
-		Config:    p.Config,
-		ConfigDir: p.ConfigDir,
 		DBPath:   p.DBPath,
 		Host:     p.Host,
 		Password: p.Password,
@@ -103,8 +99,6 @@ func (p *Pool) Ensure(ctx context.Context, dir string) (*Server, error) {
 	abs := filepath.Clean(dir)
 	s := &Server{
 		Bin:      p.Bin,
-		Config:    p.Config,
-		ConfigDir: p.ConfigDir,
 		DBPath:   p.DBPath,
 		Host:     p.Host,
 		Password: p.Password,

internal/opencode/runner.go

@@ -73,31 +73,45 @@ func (r *Runner) Run(ctx context.Context, prompt, cwd, agent, sessionID string)
 	if err != nil {
 		return nil, err
 	}
-	c := &Client{BaseURL: srv.Addr(), Password: srv.Password, Debug: r.Debug}
+	c := &Client{BaseURL: srv.Addr(), Password: srv.Password, Directory: srv.Dir, Debug: r.Debug}
 
-	// Модель по умолчанию из конфига opencode — хардпиним её в сессии, чтобы
-	// не зависеть от fallback-логики opencode (класс O5 WARN: если модель не
-	// считывается/не задана — предупреждаем и работаем без явного указания).
-	model, mErr := ReadModelRef(srv.Config, srv.ConfigDir)
-	if mErr != nil {
-		r.logf("WARN opencode: не удалось прочитать model из конфига: %v", mErr)
-	} else if model == nil {
-		r.logf("WARN opencode: в конфиге opencode не задан top-level model — модель не хардпинится (риск fallback)")
-	} else {
-		r.logf("opencode(%s) model=%s", agent, model)
-	}
-
-	// Сессия: заданная (resume) или новая.
+	// Сессия: заданная (resume) или новая. Модель НЕ выбираем — opencode сам
+	// берёт её по умолчанию из своего глобального конфига.
 	sid := sessionID
 	if sid == "" {
-		sid, err = c.CreateSession(ctx, model)
+		sid, err = c.CreateSession(ctx, agent)
 		if err != nil {
 			return nil, fmt.Errorf("opencode: create session: %w", err)
 		}
 		r.logf("opencode(%s) session=%s на %s", agent, sid, srv.Addr())
+		r.logf("opencode(%s) сообщения сессии: %s", agent, SessionMessagesURL(srv.Addr(), sid))
 	}
 
-	return r.awaitVerdict(ctx, c, model, sid, agent, prompt)
+	return r.awaitVerdict(ctx, c, sid, agent, prompt)
+}
+
+// SessionMessages возвращает транскрипт сессии (шаги агента: сообщения,
+// тексты, tool-вызовы) в хронологическом порядке для постмортем-анализа.
+// sessionID пустой → пустая строка без ошибки. Ошибки чтения возвращаются
+// как есть — вызывающий (постмортем) решает, логировать и продолжить.
+func (r *Runner) SessionMessages(ctx context.Context, cwd, sessionID string) (string, error) {
+	r.defaults()
+	if r.Pool == nil {
+		return "", fmt.Errorf("opencode: Pool не задан (API-режим обязателен)")
+	}
+	if sessionID == "" {
+		return "", nil
+	}
+	srv, err := r.Pool.Ensure(ctx, cwd)
+	if err != nil {
+		return "", err
+	}
+	c := &Client{BaseURL: srv.Addr(), Password: srv.Password, Directory: srv.Dir, Debug: r.Debug}
+	msgs, err := c.Messages(ctx, sessionID)
+	if err != nil {
+		return "", err
+	}
+	return renderTranscript(msgs), nil
 }
 
 // settlePolls — сколько подряд опросов должно подтвердить завершение ответа,
@@ -109,7 +123,7 @@ const settlePolls = 2
 // контролируя idle/hard таймауты. Завершение: сессия ушла из активных дренажей
 // И есть новое завершённое assistant-сообщение, стабильное в течение settlePolls
 // опросов. Возвращает вердикт (текст text-партов), либо rc=-1 при таймауте.
-func (r *Runner) awaitVerdict(ctx context.Context, c *Client, model *ModelRef, sid, agent, prompt string) (*Result, error) {
+func (r *Runner) awaitVerdict(ctx context.Context, c *Client, sid, agent, prompt string) (*Result, error) {
 	// admit промпта; граница «новых» сообщений — время создания user-сообщения.
 	admittedAt := time.Now().UnixMilli()
 	adm, err := c.Prompt(ctx, sid, prompt)
@@ -187,7 +201,7 @@ func (r *Runner) awaitVerdict(ctx context.Context, c *Client, model *ModelRef, s
 			doneSeen++
 			emptySeen = 0
 			if doneSeen >= settlePolls {
-				return r.verdict(model, cur, msgs, admittedAt, sid)
+				return r.verdict(cur, msgs, admittedAt, sid)
 			}
 		case !active && cur == nil:
 			// сессия завершилась, но нового assistant-сообщения так и нет
@@ -207,19 +221,17 @@ func (r *Runner) awaitVerdict(ctx context.Context, c *Client, model *ModelRef, s
 }
 
 // verdict собирает финальный результат из новых assistant-сообщений.
-// Проверяет фактическую модель ответа и логирует warning при расхождении
-// с ожидаемой (устойчивость к «не той» модели — класс O5 WARN).
-func (r *Runner) verdict(model *ModelRef, cur *v2Message, msgs []v2Message, since int64, sid string) (*Result, error) {
-	if model != nil && cur.Model != nil && (model.ProviderID != cur.Model.ProviderID || model.ID != cur.Model.ID) {
-		r.logf("WARN opencode: сессия %s отвечала моделью %s, а не ожидаемой %s — проверь providers в конфиге (v2-схема: provider.api / request, а не npm/options)", sid, cur.Model, model)
-	}
+func (r *Runner) verdict(cur *v2Message, msgs []v2Message, since int64, sid string) (*Result, error) {
 	if cur.Error != nil && cur.Error.Message != "" {
 		return nil, &ClientErr{Op: "prompt", Err: errors.New(cur.Error.Message)}
 	}
-	texts := assistantText(msgs, since)
+	texts, usedReasoning := assistantVerdict(msgs, since)
 	if len(texts) == 0 {
 		return nil, &ClientErr{Op: "prompt", Err: errors.New("нет text-части в ответе")}
 	}
+	if usedReasoning {
+		r.logf("WARN opencode: в ответе нет text-части — использую reasoning-парты как вердикт")
+	}
 	vd := stripFence(strings.Join(texts, "\n"))
 	r.logf("opencode вердикт готов (%d байт)", len(vd))
 	return &Result{RC: 0, Stdout: vd, SessionID: sid}, nil

internal/opencode/runner_test.go

@@ -10,8 +10,6 @@ import (
 
 // fakePool создаёт Pool, в котором уже «живёт» сервер для каталога (без spawn):
 // Server{URL: fake.URL}, поэтому Runner ходит по HTTP на фейк-API.
-// XDG_CONFIG_HOME уводится во временный каталог, чтобы ReadModelRef не читал
-// реальный пользовательский конфиг opencode (детерминизм тестов).
 func fakePool(t *testing.T, f *fakeAPIServer, dir string) (*Pool, *Client) {
 	t.Helper()
 	ts := httptestURL(t, f)
@@ -110,6 +108,28 @@ func TestRun_ReasoningGrowth(t *testing.T) {
 	}
 }
 
+func TestRun_ReasoningOnlyVerdict(t *testing.T) {
+	t.Setenv("XDG_CONFIG_HOME", t.TempDir())
+	dir := t.TempDir()
+	// завершённый ответ без text-парта, только reasoning — вердикт собирается
+	// из reasoning (fallback) вместо ошибки «нет text-части в ответе».
+	f := &fakeAPIServer{verdictReasoning: "размышления без текста"}
+	p, _ := fakePool(t, f, dir)
+
+	r := &Runner{Pool: p, IdleTimeout: time.Minute, HardTimeout: time.Minute,
+		PollInterval: 5 * time.Millisecond, Stdout: io.Discard}
+	res, err := r.Run(context.Background(), "task", dir, "dev", "")
+	if err != nil {
+		t.Fatalf("Run err: %v", err)
+	}
+	if res.RC != 0 {
+		t.Errorf("RC = %d, want 0 (reasoning-only вердикт)", res.RC)
+	}
+	if !contains(res.Stdout, "размышления без текста") {
+		t.Errorf("Stdout = %q, want reasoning fallback", res.Stdout)
+	}
+}
+
 func TestRun_ContextCancel(t *testing.T) {
 	t.Setenv("XDG_CONFIG_HOME", t.TempDir())
 	dir := t.TempDir()
@@ -126,7 +146,7 @@ func TestRun_ContextCancel(t *testing.T) {
 		done <- res
 		errCh <- err
 	}()
-	time.Sleep(30 * time.Millisecond)
+	time.Sleep(6000 * time.Millisecond)
 	cancel()
 	res := <-done
 	if err := <-errCh; err != nil {

internal/opencode/server.go

@@ -8,6 +8,7 @@ import (
 	"net/http"
 	"os"
 	"os/exec"
+	"path/filepath"
 	"sync"
 	"time"
 )
@@ -24,8 +25,6 @@ import (
 //     отдаёт URL, процессом не владеет.
 type Server struct {
 	Bin       string // путь к opencode (по умолчанию "opencode")
-	Config    string // OPENCODE_CONFIG
-	ConfigDir string // OPENCODE_CONFIG_DIR
 	DBPath    string // рабочая БД сервера (передам env, если задана)
 
 	Host     string // hostname для прослушивания
@@ -33,6 +32,12 @@ type Server struct {
 	Password string // basic auth (если непустой — сервер защищён)
 	Dir      string // каталог, в котором запускается serve (project сервера)
 
+	// ConfigPath — путь к глобальному конфигу opencode (opencode.jsonc).
+	// Передаётся serve через env OPENCODE_CONFIG, чтобы гарантированно
+	// подхватить модель/провайдеров независимо от резолва глобального пути.
+	// Пусто — serve резолвит конфиг сам (см. defaults).
+	ConfigPath string
+
 	// URL задаёт внешний сервер. Пусто — супервайзер владеет процессом.
 	URL         string
 	PollInterval time.Duration // как часто проверять /global/health
@@ -62,6 +67,20 @@ func (s *Server) defaults() {
 	if s.Stdout == nil {
 		s.Stdout = os.Stderr
 	}
+	if s.ConfigPath == "" {
+		s.ConfigPath = defaultOpenCodeConfigPath()
+	}
+}
+
+// defaultOpenCodeConfigPath возвращает путь к глобальному конфигу opencode,
+// совпадающий с тем, что opencode загружает по умолчанию: ~/.config/opencode/
+// (в т.ч. на Windows — см. Global.Path.config в исходниках opencode).
+func defaultOpenCodeConfigPath() string {
+	home, _ := os.UserHomeDir()
+	if home == "" {
+		home = "."
+	}
+	return filepath.Join(home, ".config", "opencode", "opencode.jsonc")
 }
 
 // baseURL собирает полный адрес сервера (http://host:port).
@@ -101,6 +120,8 @@ func (s *Server) Start(ctx context.Context) error {
 	s.done = done
 	s.mu.Unlock()
 
+	log.Printf("opencode serve: spawn dir=%s HOME=%q USERPROFILE=%q OPENCODE_CONFIG=%q (serve наследует окружение родителя)", cmd.Dir, os.Getenv("HOME"), os.Getenv("USERPROFILE"), s.ConfigPath)
+
 	if err := cmd.Start(); err != nil {
 		return fmt.Errorf("opencode serve: start %v: %w", s.Bin, err)
 	}
@@ -124,22 +145,8 @@ func (s *Server) serveCmd(ctx context.Context) *exec.Cmd {
 	// Своя process-group: чтобы killGroup (по pgid) убивал только сервер и его
 	// дочерние процессы, а не чужой процесс (например, тест-реннер).
 	setpgid(cmd)
-	env := append(os.Environ(),
-		"OPENCODE_DISABLE_AUTOUPDATE=1",
-		"OPENCODE_DISABLE_MODELS_FETCH=1")
-	if s.Config != "" {
-		env = append(env, "OPENCODE_CONFIG="+s.Config)
-	}
-	if s.ConfigDir != "" {
-		env = append(env, "OPENCODE_CONFIG_DIR="+s.ConfigDir)
-	}
-	if s.DBPath != "" {
-		env = append(env, "OPENCODE_DB="+s.DBPath)
-	}
-	if s.Password != "" {
-		env = append(env, "OPENCODE_SERVER_PASSWORD="+s.Password)
-	}
-	cmd.Env = env
+	// Env не задаём: serve наследует окружение родителя и сам резолвит свой
+	// глобальный/локальный конфиг (модель/провайдеры, агентов, БД) как обычно.
 	return cmd
 }
 

internal/opencode/server_test.go

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

internal/storage/models.go

@@ -40,6 +40,12 @@ func IsTerminal(s Status) bool {
 	return model.IsTerminal(s)
 }
 
+// Step — этап задачи с собственным критерием готовности.
+type Step struct {
+	Title string `json:"title"`
+	AC    string `json:"ac"` // acceptance criterion этапа
+}
+
 // Task — запись задачи в БД.
 type Task struct {
 	ID        int64      `json:"id"`
@@ -50,6 +56,7 @@ type Task struct {
 	Repos     []string   `json:"repos"` // список репозиториев (основной)
 	Why       string     `json:"why"`
 	AC        string     `json:"ac"`       // acceptance criteria
+	Steps     []Step     `json:"steps"`    // этапы задачи (опционально)
 	TaskTag   string     `json:"task_tag"` // UUID, стабильный на всю жизнь
 	Status    Status     `json:"status"`
 	CreatedAt SQLiteTime `json:"created_at"`
@@ -88,6 +95,25 @@ func (t *Task) SetReposFromDB(repos string) {
 	_ = json.Unmarshal([]byte(repos), &t.Repos)
 }
 
+// StepsJoined возвращает steps как одну строку (JSON-массив) для хранения в БД.
+// Пустой список → пустая строка.
+func (t *Task) StepsJoined() string {
+	if len(t.Steps) == 0 {
+		return ""
+	}
+	b, _ := json.Marshal(t.Steps)
+	return string(b)
+}
+
+// SetStepsFromDB заполняет Steps из сохранённой строки (JSON).
+func (t *Task) SetStepsFromDB(steps string) {
+	if steps == "" {
+		t.Steps = nil
+		return
+	}
+	_ = json.Unmarshal([]byte(steps), &t.Steps)
+}
+
 // TraceStatus — алиас доменного статуса трассировки.
 type TraceStatus = model.TraceStatus
 

internal/storage/storage.go

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

internal/storage/storage_test.go

@@ -150,6 +150,44 @@ func TestUpdateTaskNotFound(t *testing.T) {
 	}
 }
 
+func TestCreateAndGetTask_Steps(t *testing.T) {
+	s, ctx := setupTestDB(t)
+	task := &Task{
+		ChatID:  "tg://steps",
+		Title:   "Steps task",
+		TaskTag: "steps-1",
+		Steps: []Step{
+			{Title: "Реализовать модель", AC: "структура готова"},
+			{Title: "Добавить API", AC: "эндпоинт отвечает"},
+		},
+	}
+	id, err := s.CreateTask(ctx, task)
+	if err != nil {
+		t.Fatalf("CreateTask: %v", err)
+	}
+
+	got, err := s.GetTask(ctx, id)
+	if err != nil {
+		t.Fatalf("GetTask: %v", err)
+	}
+	if len(got.Steps) != 2 {
+		t.Fatalf("steps len = %d, want 2", len(got.Steps))
+	}
+	if got.Steps[0].Title != "Реализовать модель" || got.Steps[0].AC != "структура готова" {
+		t.Fatalf("steps[0] = %q / %q, want модель / структура готова", got.Steps[0].Title, got.Steps[0].AC)
+	}
+
+	// апдейт этапов
+	got.Steps = append(got.Steps, Step{Title: "Ревью", AC: "пройден review"})
+	if err := s.UpdateTask(ctx, got); err != nil {
+		t.Fatalf("UpdateTask steps: %v", err)
+	}
+	got2, _ := s.GetTask(ctx, id)
+	if len(got2.Steps) != 3 {
+		t.Fatalf("steps len after update = %d, want 3", len(got2.Steps))
+	}
+}
+
 func TestListTasks(t *testing.T) {
 	s, ctx := setupTestDB(t)
 	for i := 0; i < 5; i++ {
@@ -264,6 +302,26 @@ func TestUpdateTraceOutput(t *testing.T) {
 	}
 }
 
+// TestDeleteTracesByAgent — удаление трасс по агенту (сброс маркера при /retry).
+func TestDeleteTracesByAgent(t *testing.T) {
+	s, ctx := setupTestDB(t)
+	task := &Task{ChatID: "tg://del", TaskTag: "delete-by-agent"}
+	id, _ := s.CreateTask(ctx, task)
+
+	_, _ = s.AppendTrace(ctx, &Trace{TaskID: id, Agent: "dev"})
+	_, _ = s.AppendTrace(ctx, &Trace{TaskID: id, Agent: "postmortem"})
+	_, _ = s.AppendTrace(ctx, &Trace{TaskID: id, Agent: "postmortem"})
+
+	if err := s.DeleteTracesByAgent(ctx, id, "postmortem"); err != nil {
+		t.Fatalf("DeleteTracesByAgent: %v", err)
+	}
+
+	traces, _ := s.GetTraces(ctx, id)
+	if len(traces) != 1 || traces[0].Agent != "dev" {
+		t.Fatalf("traces = %d (agent %q), want только dev", len(traces), traces[0].Agent)
+	}
+}
+
 // хелперы для проверки классов ошибок
 func IsNotFound(err error) bool {
 	return errors.Is(err, ErrNotFound)

internal/storage/tasks.go

@@ -30,10 +30,10 @@ func (s *Storage) CreateTask(ctx context.Context, t *Task) (int64, error) {
 	}
 	now := Now()
 	res, err := s.db.ExecContext(ctx, `
-		INSERT INTO tasks (chat_id, title, goal, repo, repos, why, ac, task_tag, status, created_at, updated_at)
-		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+		INSERT INTO tasks (chat_id, title, goal, repo, repos, why, ac, steps, task_tag, status, created_at, updated_at)
+		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
 		t.ChatID, t.Title, t.Goal, t.Repo, t.ReposJoined(), t.Why, t.AC,
-		t.TaskTag, StatusDraft, now, now,
+		t.StepsJoined(), t.TaskTag, StatusDraft, now, now,
 	)
 	if err != nil {
 		return 0, fmt.Errorf("%w: create task: %w", ErrDB, err)
@@ -53,11 +53,12 @@ func (s *Storage) CreateTask(ctx context.Context, t *Task) (int64, error) {
 func (s *Storage) GetTask(ctx context.Context, id int64) (*Task, error) {
 	t := &Task{}
 	var reposStr string
+	var stepsStr string
 	err := s.db.QueryRowContext(ctx, `
-		SELECT id, chat_id, title, goal, repo, repos, why, ac, task_tag, status, created_at, updated_at
+		SELECT id, chat_id, title, goal, repo, repos, why, ac, steps, task_tag, status, created_at, updated_at
 		FROM tasks WHERE id = ?`, id).Scan(
 		&t.ID, &t.ChatID, &t.Title, &t.Goal, &t.Repo, &reposStr,
-		&t.Why, &t.AC, &t.TaskTag, &t.Status, &t.CreatedAt, &t.UpdatedAt,
+		&t.Why, &t.AC, &stepsStr, &t.TaskTag, &t.Status, &t.CreatedAt, &t.UpdatedAt,
 	)
 	if err == sql.ErrNoRows {
 		return nil, fmt.Errorf("%w: task %d", ErrNotFound, id)
@@ -66,6 +67,7 @@ func (s *Storage) GetTask(ctx context.Context, id int64) (*Task, error) {
 		return nil, fmt.Errorf("%w: get task %d: %w", ErrDB, id, err)
 	}
 	t.SetReposFromDB(reposStr)
+	t.SetStepsFromDB(stepsStr)
 	return t, nil
 }
 
@@ -94,9 +96,9 @@ func (s *Storage) UpdateTask(ctx context.Context, t *Task) error {
 	now := Now()
 	res, err := s.db.ExecContext(ctx, `
 		UPDATE tasks
-		SET title=?, goal=?, repo=?, repos=?, why=?, ac=?, status=?, updated_at=?
+		SET title=?, goal=?, repo=?, repos=?, why=?, ac=?, steps=?, status=?, updated_at=?
 		WHERE id=?`,
-		t.Title, t.Goal, t.Repo, t.ReposJoined(), t.Why, t.AC, t.Status, now, t.ID,
+		t.Title, t.Goal, t.Repo, t.ReposJoined(), t.Why, t.AC, t.StepsJoined(), t.Status, now, t.ID,
 	)
 	if err != nil {
 		return fmt.Errorf("%w: update task %d: %w", ErrDB, t.ID, err)
@@ -114,13 +116,14 @@ func (s *Storage) UpdateTask(ctx context.Context, t *Task) error {
 func (s *Storage) GetActiveTaskByChatID(ctx context.Context, chatID string) (*Task, error) {
 	t := &Task{}
 	var reposStr string
+	var stepsStr string
 	err := s.db.QueryRowContext(ctx, `
-		SELECT id, chat_id, title, goal, repo, repos, why, ac, task_tag, status, created_at, updated_at
+		SELECT id, chat_id, title, goal, repo, repos, why, ac, steps, task_tag, status, created_at, updated_at
 		FROM tasks
 		WHERE chat_id = ? AND status NOT IN ('success','cancelled','aborted','closed')
 		ORDER BY updated_at DESC LIMIT 1`, chatID).Scan(
 		&t.ID, &t.ChatID, &t.Title, &t.Goal, &t.Repo, &reposStr,
-		&t.Why, &t.AC, &t.TaskTag, &t.Status, &t.CreatedAt, &t.UpdatedAt)
+		&t.Why, &t.AC, &stepsStr, &t.TaskTag, &t.Status, &t.CreatedAt, &t.UpdatedAt)
 	if err == sql.ErrNoRows {
 		return nil, fmt.Errorf("%w: no active task for chat %s", ErrNotFound, chatID)
 	}
@@ -128,6 +131,7 @@ func (s *Storage) GetActiveTaskByChatID(ctx context.Context, chatID string) (*Ta
 		return nil, fmt.Errorf("%w: get active task %s: %w", ErrDB, chatID, err)
 	}
 	t.SetReposFromDB(reposStr)
+	t.SetStepsFromDB(stepsStr)
 	return t, nil
 }
 
@@ -149,7 +153,7 @@ func (s *Storage) ListTasks(ctx context.Context, filter TaskFilter) ([]*Task, er
 	args = append(args, filter.Limit, filter.Offset)
 
 	rows, err := s.db.QueryContext(ctx, `
-		SELECT id, chat_id, title, goal, repo, repos, why, ac, task_tag, status, created_at, updated_at
+		SELECT id, chat_id, title, goal, repo, repos, why, ac, steps, task_tag, status, created_at, updated_at
 		FROM tasks WHERE `+where+` ORDER BY updated_at DESC LIMIT ? OFFSET ?`, args...)
 	if err != nil {
 		return nil, fmt.Errorf("%w: list tasks: %w", ErrDB, err)
@@ -160,11 +164,13 @@ func (s *Storage) ListTasks(ctx context.Context, filter TaskFilter) ([]*Task, er
 	for rows.Next() {
 		t := &Task{}
 		var reposStr string
+		var stepsStr string
 		if err := rows.Scan(&t.ID, &t.ChatID, &t.Title, &t.Goal, &t.Repo, &reposStr,
-			&t.Why, &t.AC, &t.TaskTag, &t.Status, &t.CreatedAt, &t.UpdatedAt); err != nil {
+			&t.Why, &t.AC, &stepsStr, &t.TaskTag, &t.Status, &t.CreatedAt, &t.UpdatedAt); err != nil {
 			return nil, fmt.Errorf("%w: scan task: %w", ErrDB, err)
 		}
 		t.SetReposFromDB(reposStr)
+		t.SetStepsFromDB(stepsStr)
 		tasks = append(tasks, t)
 	}
 	return tasks, rows.Err()

internal/storage/traces.go

@@ -107,6 +107,17 @@ func (s *Storage) GetLatestTrace(ctx context.Context, taskID int64, agent string
 	return tr, nil
 }
 
+// DeleteTracesByAgent удаляет все трассы задачи с заданным агентом
+// (сброс маркера при /retry N: чистый перезапуск без наследия анализа).
+func (s *Storage) DeleteTracesByAgent(ctx context.Context, taskID int64, agent string) error {
+	_, err := s.db.ExecContext(ctx,
+		`DELETE FROM traces WHERE task_id=? AND agent=?`, taskID, agent)
+	if err != nil {
+		return fmt.Errorf("%w: delete traces agent %s for task %d: %w", ErrDB, agent, taskID, err)
+	}
+	return nil
+}
+
 // DeleteTrace удаляет трассу. Только для тестов/админки.
 func (s *Storage) DeleteTrace(ctx context.Context, id int64) error {
 	res, err := s.db.ExecContext(ctx, `DELETE FROM traces WHERE id = ?`, id)

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

internal/worker/postmortem.go

@@ -0,0 +1,242 @@
+package worker
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"strings"
+	"text/template"
+
+	"github.com/kamelion/ratatoskr-go/internal/events"
+	"github.com/kamelion/ratatoskr-go/internal/storage"
+)
+
+// postMortemAgent — имя постмортем-агента (файл agents/postmortem.md).
+const postMortemAgent = "postmortem"
+
+// traceOutputMax — обрезка вывода сессии в постмортем-промпте (чтобы промпт
+// не превращался в полные транскрипты и не переполнял контекст модели).
+const traceOutputMax = 6000
+
+// sessionTranscriptMax — обрезка транскрипта сессии dev/reviewer в промпте.
+const sessionTranscriptMax = 20000
+
+// postMortemPromptTemplate — промпт для постмортем-агента после failed/timeout:
+// задача + сессии dev/reviewer. Ожидается резюме простым текстом на русском.
+var postMortemPromptTemplate = template.Must(template.New("postmortem").Parse(`Ты — постмортем-аналитик в конвейере Ratatoskr. Задача завершилась неудачей ({{.Status}}). Проанализируй сессии агентов dev/reviewer и дай резюме: почему так случилось и что сделать, чтобы не повторялось.
+
+**Задача:**
+{{if .Title}}Название: {{.Title}}{{end}}
+{{if .Goal}}Цель: {{.Goal}}{{end}}
+{{if .Repos}}
+Репозитории:
+{{- range .Repos}}
+  - {{.}}
+{{- end}}
+{{end}}
+{{if .Why}}Зачем: {{.Why}}{{end}}
+{{if .AC}}Критерии готовности (AC):
+{{.AC}}{{end}}
+
+**Итоговый статус задачи:** {{.Status}}
+
+**Сессии субагентов:**
+{{.Sessions}}
+
+Ответь ПРОСТЫМ ТЕКСТОМ на русском, без JSON и разметки. Формат:
+
+Почему так случилось:
+- <причина 1>
+- <причина 2>
+
+Что сделать, чтобы это не повторялось:
+- <рекомендация 1>
+- <рекомендация 2>`))
+
+// PostMortemPromptData — данные для рендера постмортем-промпта.
+type PostMortemPromptData struct {
+	Title    string
+	Goal     string
+	Repos    []string
+	Why      string
+	AC       string
+	Status   storage.Status
+	Sessions string
+}
+
+// RenderPostMortemPrompt собирает промпт для постмортем-агента.
+func RenderPostMortemPrompt(data PostMortemPromptData) (string, error) {
+	var buf strings.Builder
+	if err := postMortemPromptTemplate.Execute(&buf, data); err != nil {
+		return "", err
+	}
+	return buf.String(), nil
+}
+
+// postMortemsText форматирует сессии dev/reviewer в секцию промпта: поля
+// трассы (session_id, промпт, вывод) + транскрипт сессии (шаги агента).
+// transcripts — sessionID → транскрипт (пустая строка — в сессии нет сообщений);
+// отсутствие ключа — транскрипт недоступен (сбой чтения).
+func postMortemsText(traces []storage.Trace, transcripts map[string]string) string {
+	var b strings.Builder
+	for _, tr := range traces {
+		b.WriteString("\n=== Агент: " + tr.Agent + " (статус " + string(tr.Status) + ") ===\n")
+		if tr.SessionID != "" {
+			b.WriteString("session_id: " + tr.SessionID + "\n")
+		}
+		if strings.TrimSpace(tr.Prompt) != "" {
+			b.WriteString("-- Промпт агента --\n")
+			b.WriteString(tr.Prompt)
+			b.WriteString("\n")
+		}
+		if strings.TrimSpace(tr.Output) != "" {
+			b.WriteString("-- Вывод агента --\n")
+			b.WriteString(truncateTrace(tr.Output, traceOutputMax))
+			b.WriteString("\n")
+		}
+		if tr.SessionID != "" {
+			tx, ok := transcripts[tr.SessionID]
+			b.WriteString("-- Транскрипт сессии (шаги агента) --\n")
+			switch {
+			case !ok:
+				b.WriteString("(транскрипт сессии недоступен)\n")
+			case strings.TrimSpace(tx) == "":
+				b.WriteString("(в сессии нет сообщений — агент не сделал ни одного шага)\n")
+			default:
+				b.WriteString(truncateTrace(tx, sessionTranscriptMax))
+				b.WriteString("\n")
+			}
+		}
+	}
+	if b.Len() == 0 {
+		return "(сессии dev/reviewer не найдены — вероятна инфраструктурная ошибка до запуска агентов)"
+	}
+	return b.String()
+}
+
+// truncateTrace обрезает длинный текст до последних n символов (релевантен
+// хвост: вердикт/ошибка агента в конце вывода).
+func truncateTrace(s string, n int) string {
+	if len(s) <= n {
+		return s
+	}
+	if n <= 0 {
+		return ""
+	}
+	return "(вывод обрезан)\n" + s[len(s)-n:]
+}
+
+// hasPostMortemTrace возвращает true, если у задачи уже есть постмортем-trace
+// (защита от повторного запуска при повторных прогонах/retry).
+func (w *Worker) hasPostMortemTrace(ctx context.Context, taskID int64) bool {
+	if w.Store == nil {
+		return false
+	}
+	_, err := w.Store.GetLatestTrace(ctx, taskID, postMortemAgent)
+	return err == nil
+}
+
+// postMortem запускает постмортем-агент для задачи, завершившейся failed/timeout:
+// собирает сессии dev/reviewer из трасс, даёт агенту анализ, сохраняет результат
+// как trace agent=postmortem и уведомляет владельца задачи резюме.
+//
+// Статус задачи НЕ меняется (failed/timeout остаётся достигнутым); собственные
+// сбои постмортема не влияют на исход задачи — только логируются.
+func (w *Worker) postMortem(ctx context.Context, task *storage.Task) {
+	if w.Store == nil || w.Runner == nil {
+		return
+	}
+	if w.hasPostMortemTrace(ctx, task.ID) {
+		return
+	}
+
+	traces, err := w.Store.GetTraces(ctx, task.ID)
+	if err != nil {
+		log.Printf("worker: task %d: постмортем: трассы: %v", task.ID, err)
+		return
+	}
+	// Анализируем только сессии агентов конвейера (dev/reviewer).
+	var sessions []storage.Trace
+	for _, tr := range traces {
+		if tr.Agent == "dev" || tr.Agent == "reviewer" {
+			sessions = append(sessions, *tr)
+		}
+	}
+
+	// Достаём транскрипты сессий dev/reviewer (по session_id) — реальные шаги
+	// агента (сообщения/tool-вызовы), которые не попадают в трассу (там только
+	// финальный вывод). Сбои чтения не фатальны: промпт соберётся без них.
+	transcripts := make(map[string]string, len(sessions))
+	for i := range sessions {
+		tr := &sessions[i]
+		if tr.SessionID == "" {
+			continue
+		}
+		tx, tErr := w.Runner.SessionMessages(w.runCtx(ctx, task.ID), w.Worktree, tr.SessionID)
+		if tErr != nil {
+			log.Printf("worker: task %d: постмортем: транскрипт %s (%s): %v", task.ID, tr.Agent, tr.SessionID, tErr)
+			continue
+		}
+		transcripts[tr.SessionID] = tx
+	}
+
+	prompt, pErr := RenderPostMortemPrompt(PostMortemPromptData{
+		Title:    task.Title,
+		Goal:     task.Goal,
+		Repos:    task.EffectiveRepos(),
+		Why:      task.Why,
+		AC:       task.AC,
+		Status:   task.Status,
+		Sessions: postMortemsText(sessions, transcripts),
+	})
+	if pErr != nil {
+		log.Printf("worker: task %d: постмортем: рендер промпта: %v", task.ID, pErr)
+		return
+	}
+
+	// лог-событие для UI-панели «Состояние».
+	w.publish(events.AgentActivity{TaskID: task.ID, Agent: postMortemAgent, Stage: "postmortem"})
+
+	tr := &storage.Trace{TaskID: task.ID, Agent: postMortemAgent, Prompt: prompt}
+	traceID, aErr := w.Store.AppendTrace(ctx, tr)
+	if aErr != nil {
+		log.Printf("worker: task %d: постмортем: create trace: %v", task.ID, aErr)
+		return
+	}
+
+	res, rErr := w.Runner.Run(w.runCtx(ctx, task.ID), prompt, w.Worktree, postMortemAgent, "")
+	if rErr != nil {
+		log.Printf("worker: task %d: постмортем: запуск: %v", task.ID, rErr)
+		w.finalizeTrace(ctx, traceID, storage.TraceFailed, rErr.Error())
+		return
+	}
+	if res.SessionID != "" {
+		_ = w.Store.UpdateTraceSessionID(ctx, traceID, res.SessionID)
+	}
+
+	output := strings.TrimSpace(res.Stdout)
+	status := storage.TraceSuccess
+	if res.RC != 0 || output == "" {
+		status = storage.TraceFailed
+		if output == "" {
+			output = "(постмортем-агент не вернул текст)"
+		}
+	}
+	log.Printf("worker: task %d: постмортем: %s", task.ID, truncateTrace(output, 2000))
+	w.finalizeTrace(ctx, traceID, status, output)
+
+	if res.RC == 0 && output != "" {
+		text := fmt.Sprintf("Задача #%d: 🔍 анализ (после %s)\n%s", task.ID, task.Status, output)
+		w.notify(ctx, task, text)
+	}
+}
+
+// postMortemAfter — defer-хук из runTask: запускает постмортем, если задача
+// завершилась failed/timeout. Собственные ошибки постмортема не мешают
+// исходному результату задачи (возвращаемый *error только читается).
+func (w *Worker) postMortemAfter(ctx context.Context, task *storage.Task, _ *error) {
+	if task.Status != storage.StatusFailed && task.Status != storage.StatusTimeout {
+		return
+	}
+	w.postMortem(ctx, task)
+}

internal/worker/prompt.go

@@ -3,6 +3,8 @@ package worker
 import (
 	"strings"
 	"text/template"
+
+	"github.com/kamelion/ratatoskr-go/internal/storage"
 )
 
 // devPromptTemplate — промпт для dev-агента при запуске задачи.
@@ -20,6 +22,12 @@ var devPromptTemplate = template.Must(template.New("dev").Parse(`Ты — dev-а
 {{if .Why}}Зачем: {{.Why}}{{end}}
 {{if .AC}}Критерии готовности:
 {{.AC}}{{end}}
+{{if .Steps}}
+**Этапы (выполняй по порядку, у каждого свой критерий готовности):**
+{{- range .Steps}}
+{{.Title}}{{if .AC}} — готово, когда: {{.AC}}{{end}}
+{{- end}}
+{{end}}
 
 **Инструкции:**
 1. Рабочий каталог — общий корень, в котором лежат все репозитории по именам.
@@ -38,6 +46,7 @@ type DevPromptData struct {
 	Repos []string
 	Why   string
 	AC    string
+	Steps []storage.Step
 
 	// ReviewFeedback — замечания ревьюера при повторном прогоне dev
 	// (не пусто → dev должен исправить именно это).

internal/worker/review.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"log"
 	"path/filepath"
 	"strings"
 
@@ -96,6 +97,10 @@ func (w *Worker) runReviewer(ctx context.Context, taskID int64, cwd, prompt stri
 	}
 	w.finalizeTrace(ctx, traceID, ts, output)
 
+	if v != nil {
+		log.Printf("reviewer: вердикт: %s", formatReviewVerdict(v))
+	}
+
 	if v == nil {
 		// Невалидный/пустой вывод или RC!=0: не парсится — сигнал на retry.
 		return nil, output, traceID, nil
@@ -119,3 +124,35 @@ func parseReviewVerdict(out string) (*reviewVerdict, error) {
 	}
 	return &v, nil
 }
+
+// formatReviewVerdict собирает человекочитаемое однострочное описание вердикта
+// ревьюера (без JSON-разметки) для панели «Логи».
+func formatReviewVerdict(v *reviewVerdict) string {
+	var b strings.Builder
+	b.WriteString("passed=")
+	b.WriteString(boolElse(v.Passed, "yes", "no"))
+	if len(v.CriticalIssues) > 0 {
+		b.WriteString(", critical=[")
+		b.WriteString(strings.Join(v.CriticalIssues, " | "))
+		b.WriteString("]")
+	}
+	if len(v.SolidViolations) > 0 {
+		b.WriteString(", solid=[")
+		b.WriteString(strings.Join(v.SolidViolations, " | "))
+		b.WriteString("]")
+	}
+	if len(v.Comments) > 0 {
+		b.WriteString(", comments=[")
+		b.WriteString(strings.Join(v.Comments, " | "))
+		b.WriteString("]")
+	}
+	return b.String()
+}
+
+// boolElse возвращает строку для логического значения (без вызова тернарника).
+func boolElse(cond bool, yes, no string) string {
+	if cond {
+		return yes
+	}
+	return no
+}

internal/worker/worker.go

@@ -18,6 +18,9 @@ import (
 // OpenCodeRunner — интерфейс для opencode (подменяемый в тестах).
 type OpenCodeRunner interface {
 	Run(ctx context.Context, prompt, cwd, agent, sessionID string) (*opencode.Result, error)
+	// SessionMessages возвращает транскрипт сессии (шаги агента) по sessionID
+	// для постмортем-анализа. cwd — каталог, где живёт сервер пула сессии.
+	SessionMessages(ctx context.Context, cwd, sessionID string) (string, error)
 }
 
 // PollTaskFunc — callback для обработки готовой задачи (подменяемый в тестах).
@@ -196,6 +199,10 @@ func (w *Worker) pollAndDispatch(ctx context.Context) error {
 // dev-агент реализует, reviewer строго проверяет весь дифф ветки; при не-проходе
 // dev дорабатывает по комментариям; прошло → push ветки + success.
 func (w *Worker) runTask(ctx context.Context, task *storage.Task) (err error) {
+	// 0. постмортем-анализ: если задача завершилась failed/timeout — после
+	// выхода из runTask (всех путей) запускаем анализ сессий dev/reviewer.
+	defer w.postMortemAfter(ctx, task, &err)
+
 	// 1. проверяем статус
 	if task.Status != storage.StatusApproved {
 		return fmt.Errorf("%w: task %d status=%q", ErrLaunch, task.ID, task.Status)
@@ -248,6 +255,7 @@ func (w *Worker) runTask(ctx context.Context, task *storage.Task) (err error) {
 			Repos:          repos,
 			Why:            task.Why,
 			AC:             task.AC,
+			Steps:          task.Steps,
 			Branch:         branch,
 			ReviewFeedback: reviewFeedbackList(branch, feedback),
 		}
@@ -277,6 +285,8 @@ func (w *Worker) runTask(ctx context.Context, task *storage.Task) (err error) {
 
 		output := res.Stdout
 
+		log.Printf("worker: task %d: dev вердикт (хвост): %s", task.ID, truncateTrace(output, 2000))
+
 		// 5b. dev не завершился успешно (RC!=0) → фиксируем без ревью.
 		switch res.RC {
 		case 0:

internal/worker/worker_test.go

@@ -54,6 +54,16 @@ type mockRunnerWorker struct {
 	// (последний вечный). Позволяет смоделировать fail-then-pass.
 	reviewSequence []*opencode.Result
 	reviewCount    int
+
+	// postMortemResult — результат постмортем-агента; nil → RC:0 с тестовым
+	// резюме. postMortemCount — сколько раз постмортем вызывался.
+	postMortemResult *opencode.Result
+	postMortemCount  int
+
+	// sessionTranscripts — sessionID → транскрипт для постмортем-агента;
+	// sessionMsgsErr — ошибка чтения транскрипта.
+	sessionTranscripts map[string]string
+	sessionMsgsErr     error
 }
 
 func (m *mockRunnerWorker) Run(_ context.Context, _, _, agent, _ string) (*opencode.Result, error) {
@@ -71,9 +81,23 @@ func (m *mockRunnerWorker) Run(_ context.Context, _, _, agent, _ string) (*openc
 		}
 		return &opencode.Result{RC: 0, Stdout: `{"passed":true,"comments":[]}`}, nil
 	}
+	if agent == postMortemAgent {
+		m.postMortemCount++
+		if m.postMortemResult != nil {
+			return m.postMortemResult, m.err
+		}
+		return &opencode.Result{RC: 0, Stdout: "Почему так случилось:\n- тестовое резюме\nЧто сделать:\n- исправить"}, nil
+	}
 	return m.result, m.err
 }
 
+func (m *mockRunnerWorker) SessionMessages(_ context.Context, _, sessionID string) (string, error) {
+	if m.sessionMsgsErr != nil {
+		return "", m.sessionMsgsErr
+	}
+	return m.sessionTranscripts[sessionID], nil
+}
+
 // reviewFailedRunner возвращает вердикт not-passed с комментариями.
 func reviewFailedRunner() *opencode.Result {
 	return &opencode.Result{RC: 0, Stdout: `{"passed":false,"critical_issues":[],"solid_violations":["DIP: высокая связанность"],"comments":["исправь связанность"]}`}
@@ -402,12 +426,17 @@ func TestWorkerIterationsLimitNotification(t *testing.T) {
 	if len(texts) == 0 {
 		t.Fatal("нет уведомлений")
 	}
-	last := texts[len(texts)-1]
-	if !strings.Contains(last, "failed") {
-		t.Errorf("последнее уведомление = %q, want упоминание failed", last)
+	// где-то в списке есть уведомление о failed с упоминанием лимита итераций
+	// (над ним — уведомление postmortem, поэтому последним оно не обязано быть).
+	var limitNotif string
+	for _, txt := range texts {
+		if strings.Contains(txt, "failed") && strings.Contains(txt, "итераци") {
+			limitNotif = txt
+			break
 		}
-	if !strings.Contains(last, "итераци") {
-		t.Errorf("последнее уведомление = %q, want упоминание лимита итераций", last)
+	}
+	if limitNotif == "" {
+		t.Errorf("нет уведомления о лимите итераций (failed+итераци): %#v", texts)
 	}
 	// ровно одно уведомление о failed (running→failed не задваивается)
 	var failedCount int
@@ -419,9 +448,20 @@ func TestWorkerIterationsLimitNotification(t *testing.T) {
 	if failedCount != 1 {
 		t.Errorf("уведомлений о failed = %d, want ровно 1: %#v", failedCount, texts)
 	}
+	// есть постмортем-уведомление с анализом
+	var pmCount int
+	for _, txt := range texts {
+		if strings.Contains(txt, "анализ (после failed)") {
+			pmCount++
+		}
+	}
+	if pmCount != 1 {
+		t.Errorf("постмортем-уведомлений = %d, want ровно 1: %#v", pmCount, texts)
+	}
 }
 
-// TestWorkerTimeoutNotification — RC=-1 (таймаут dev) → уведомление о timeout.
+// TestWorkerTimeoutNotification — RC=-1 (таймаут dev) → уведомление о timeout
+// и постмортем-уведомление с анализом.
 func TestWorkerTimeoutNotification(t *testing.T) {
 	s := setupWorkerDB(t)
 	task := createReadyTask(t, s, "notif-timeout")
@@ -439,13 +479,21 @@ func TestWorkerTimeoutNotification(t *testing.T) {
 	_ = w.runTask(ctx, task)
 
 	prefix := "Задача #" + strconv.FormatInt(task.ID, 10)
+	texts := notifTexts(n)
+	if len(texts) != 3 {
+		t.Fatalf("уведомлений = %d, want 3: %#v", len(texts), texts)
+	}
 	want := []string{prefix + ": running", prefix + ": timeout"}
-	if got := notifTexts(n); !reflect.DeepEqual(got, want) {
-		t.Errorf("уведомления = %#v, want %#v", got, want)
+	if !reflect.DeepEqual(texts[:2], want) {
+		t.Errorf("первые уведомления = %#v, want %#v", texts[:2], want)
+	}
+	if !strings.Contains(texts[2], "🔍 анализ (после timeout)") {
+		t.Errorf("постмортем-уведомление = %q, want упоминание «анализ (после timeout)»", texts[2])
 	}
 }
 
-// TestWorkerSpawnErrorNotification — сбой запуска dev → уведомление о failed.
+// TestWorkerSpawnErrorNotification — сбой запуска dev → уведомление о failed
+// и постмортем-уведомление.
 func TestWorkerSpawnErrorNotification(t *testing.T) {
 	s := setupWorkerDB(t)
 	task := createReadyTask(t, s, "notif-spawn")
@@ -463,9 +511,16 @@ func TestWorkerSpawnErrorNotification(t *testing.T) {
 	_ = w.runTask(ctx, task)
 
 	prefix := "Задача #" + strconv.FormatInt(task.ID, 10)
+	texts := notifTexts(n)
+	if len(texts) != 3 {
+		t.Fatalf("уведомлений = %d, want 3: %#v", len(texts), texts)
+	}
 	want := []string{prefix + ": running", prefix + ": failed"}
-	if got := notifTexts(n); !reflect.DeepEqual(got, want) {
-		t.Errorf("уведомления = %#v, want %#v", got, want)
+	if !reflect.DeepEqual(texts[:2], want) {
+		t.Errorf("первые уведомления = %#v, want %#v", texts[:2], want)
+	}
+	if !strings.Contains(texts[2], "анализ (после failed)") {
+		t.Errorf("постмортем-уведомление = %q, want упоминание «анализ (после failed)»", texts[2])
 	}
 }
 
@@ -529,9 +584,10 @@ func TestWorkerTimeout(t *testing.T) {
 	s := setupWorkerDB(t)
 	task := createReadyTask(t, s, "slow")
 
+	runner := &mockRunnerWorker{result: &opencode.Result{RC: -1, Stdout: ""}}
 	w := &Worker{
 		Store:    s,
-		Runner:   &mockRunnerWorker{result: &opencode.Result{RC: -1, Stdout: ""}},
+		Runner:   runner,
 		Worktree: t.TempDir(),
 	}
 	seedFakeRepo(t, w.Worktree, "slow")
@@ -551,11 +607,20 @@ func TestWorkerTimeout(t *testing.T) {
 	if err != nil {
 		t.Fatalf("get traces: %v", err)
 	}
-	if len(traces) != 1 {
-		t.Fatalf("got %d traces, want 1", len(traces))
+	if len(traces) != 2 {
+		t.Fatalf("got %d traces, want 2 (dev + postmortem)", len(traces))
 	}
 	if traces[0].Status != storage.TraceTimeout {
-		t.Errorf("trace status = %q, want timeout", traces[0].Status)
+		t.Errorf("trace[0] status = %q, want timeout", traces[0].Status)
+	}
+	if traces[1].Agent != postMortemAgent {
+		t.Errorf("trace[1] agent = %q, want postmortem", traces[1].Agent)
+	}
+	if traces[1].Status != storage.TraceSuccess {
+		t.Errorf("trace[1] status = %q, want success", traces[1].Status)
+	}
+	if runner.postMortemCount != 1 {
+		t.Errorf("postmortem запускался %d раз, want 1", runner.postMortemCount)
 	}
 }
 
@@ -563,9 +628,10 @@ func TestWorkerSpawnError(t *testing.T) {
 	s := setupWorkerDB(t)
 	task := createReadyTask(t, s, "spawn-fail")
 
+	runner := &mockRunnerWorker{err: errors.New("opencode not found")}
 	w := &Worker{
 		Store:    s,
-		Runner:   &mockRunnerWorker{err: errors.New("opencode not found")},
+		Runner:   runner,
 		Worktree: t.TempDir(),
 	}
 	seedFakeRepo(t, w.Worktree, "spawn-fail")
@@ -585,11 +651,17 @@ func TestWorkerSpawnError(t *testing.T) {
 	if err != nil {
 		t.Fatalf("get traces: %v", err)
 	}
-	if len(traces) != 1 {
-		t.Fatalf("got %d traces, want 1", len(traces))
+	if len(traces) != 2 {
+		t.Fatalf("got %d traces, want 2 (dev-failed + postmortem)", len(traces))
 	}
 	if traces[0].Status != storage.TraceFailed {
-		t.Errorf("trace status = %q, want failed", traces[0].Status)
+		t.Errorf("trace[0] status = %q, want failed", traces[0].Status)
+	}
+	if traces[1].Agent != postMortemAgent {
+		t.Errorf("trace[1] agent = %q, want postmortem", traces[1].Agent)
+	}
+	if runner.postMortemCount != 1 {
+		t.Errorf("postmortem запускался %d раз, want 1", runner.postMortemCount)
 	}
 }
 
@@ -619,8 +691,8 @@ func TestWorkerNonZeroExit(t *testing.T) {
 	if err != nil {
 		t.Fatalf("get traces: %v", err)
 	}
-	if len(traces) != 1 {
-		t.Fatalf("got %d traces, want 1", len(traces))
+	if len(traces) != 2 {
+		t.Fatalf("got %d traces, want 2 (dev + postmortem)", len(traces))
 	}
 	if traces[0].Status != storage.TraceFailed {
 		t.Errorf("trace status = %q, want failed", traces[0].Status)
@@ -628,6 +700,9 @@ func TestWorkerNonZeroExit(t *testing.T) {
 	if traces[0].Output != "error" {
 		t.Errorf("output = %q, want error", traces[0].Output)
 	}
+	if traces[1].Agent != postMortemAgent {
+		t.Errorf("trace[1] agent = %q, want postmortem", traces[1].Agent)
+	}
 }
 
 func TestWorkerBadStatus(t *testing.T) {
@@ -650,6 +725,7 @@ func TestWorkerBadStatus(t *testing.T) {
 	}
 }
 
+// TestWorkerPromptRendered — dev-промпт собирается из полей задачи.
 func TestWorkerPromptRendered(t *testing.T) {
 	s := setupWorkerDB(t)
 	task := createReadyTask(t, s, "prompt-test")
@@ -683,6 +759,63 @@ func TestWorkerPromptRendered(t *testing.T) {
 	}
 }
 
+// TestWorkerPromptIncludesSteps — этапы задачи попадают в dev-промпт по порядку
+// с критериями готовности.
+func TestWorkerPromptIncludesSteps(t *testing.T) {
+	s := setupWorkerDB(t)
+	task := createReadyTask(t, s, "steps-test")
+
+	ctx := context.Background()
+	task.Steps = []storage.Step{
+		{Title: "Модель", AC: "операции готовы"},
+		{Title: "UI"},
+	}
+	if err := s.UpdateTask(ctx, task); err != nil {
+		t.Fatalf("update steps: %v", err)
+	}
+
+	w := &Worker{
+		Store:    s,
+		Runner:   &mockRunnerWorker{result: &opencode.Result{RC: 0, Stdout: "ok", SessionID: "s"}},
+		Worktree: t.TempDir(),
+	}
+	seedFakeRepo(t, w.Worktree, "steps-test")
+
+	_ = w.runTask(ctx, task)
+
+	traces, err := s.GetTraces(ctx, task.ID)
+	if err != nil {
+		t.Fatalf("get traces: %v", err)
+	}
+	tr := traces[0]
+	for _, want := range []string{"Этапы", "Модель", "операции готовы", "UI"} {
+		if !strings.Contains(tr.Prompt, want) {
+			t.Errorf("dev-промпт не содержит %q", want)
+		}
+	}
+}
+
+// TestRenderDevPromptSteps — прямой рендер dev-промпта с этапами.
+func TestRenderDevPromptSteps(t *testing.T) {
+	prompt, err := RenderDevPrompt(DevPromptData{
+		Title: "Калькулятор",
+		AC:    "работает",
+		Steps: []storage.Step{
+			{Title: "Модель", AC: "операции готовы"},
+			{Title: "UI"},
+		},
+		Branch: "feat/abc",
+	})
+	if err != nil {
+		t.Fatalf("render: %v", err)
+	}
+	for _, want := range []string{"Этапы", "Модель — готово, когда: операции готовы", "UI"} {
+		if !strings.Contains(prompt, want) {
+			t.Errorf("prompt не содержит %q", want)
+		}
+	}
+}
+
 func TestFeatureBranchName(t *testing.T) {
 	cases := []struct {
 		tag  string
@@ -882,3 +1015,267 @@ func TestWorkerSemaphore(t *testing.T) {
 		t.Errorf("после освобождения слота success = %d, want 2", len(success))
 	}
 }
+
+// TestWorkerPostMortemSkippedOnSuccess — успешный трейд НЕ запускает постмортем:
+// причина анализа — только failed/timeout.
+func TestWorkerPostMortemSkippedOnSuccess(t *testing.T) {
+	s := setupWorkerDB(t)
+	task := createReadyTask(t, s, "pm-ok")
+
+	runner := &mockRunnerWorker{result: &opencode.Result{RC: 0, Stdout: "done", SessionID: "s"}}
+	w := &Worker{
+		Store:    s,
+		Runner:   runner,
+		Worktree: t.TempDir(),
+	}
+	seedFakeRepo(t, w.Worktree, "pm-ok")
+
+	ctx := context.Background()
+	if err := w.runTask(ctx, task); err != nil {
+		t.Fatalf("runTask: %v", err)
+	}
+	task, _ = s.GetTask(ctx, task.ID)
+	if task.Status != storage.StatusSuccess {
+		t.Fatalf("status = %q, want success", task.Status)
+	}
+	if runner.postMortemCount != 0 {
+		t.Errorf("postmortem запускался %d раз, want 0 при success", runner.postMortemCount)
+	}
+	traces, _ := s.GetTraces(ctx, task.ID)
+	for _, tr := range traces {
+		if tr.Agent == postMortemAgent {
+			t.Errorf("есть неожиданный postmortem-trace при success")
+		}
+	}
+}
+
+// TestWorkerPostMortemFailureDoesNotChangeStatus — сбой самого постмортема не
+// влияет на статус задачи (остаётся failed) и фиксируется как failed-трасса.
+func TestWorkerPostMortemFailureDoesNotChangeStatus(t *testing.T) {
+	s := setupWorkerDB(t)
+	task := createReadyTask(t, s, "pm-fail")
+
+	runner := &mockRunnerWorker{
+		// dev падает при спавне → failed; постмортем тоже падает.
+		err:              errors.New("opencode not found"),
+		postMortemResult: &opencode.Result{RC: 1, Stdout: ""},
+	}
+	w := &Worker{
+		Store:    s,
+		Runner:   runner,
+		Worktree: t.TempDir(),
+	}
+	seedFakeRepo(t, w.Worktree, "pm-fail")
+
+	ctx := context.Background()
+	_ = w.runTask(ctx, task)
+
+	task, _ = s.GetTask(ctx, task.ID)
+	if task.Status != storage.StatusFailed {
+		t.Errorf("status = %q, want failed (постмортем не должен менять статус)", task.Status)
+	}
+	traces, err := s.GetTraces(ctx, task.ID)
+	if err != nil {
+		t.Fatalf("get traces: %v", err)
+	}
+	if len(traces) != 2 {
+		t.Fatalf("traces = %d, want 2 (dev-failed + postmortem)", len(traces))
+	}
+	if traces[1].Agent != postMortemAgent {
+		t.Errorf("trace[1] agent = %q, want postmortem", traces[1].Agent)
+	}
+	if traces[1].Status != storage.TraceFailed {
+		t.Errorf("trace[1] status = %q, want failed (сбой постмортема)", traces[1].Status)
+	}
+}
+
+// TestWorkerPostMortemNotRepeated — если у задачи уже есть postmortem-trace
+// (например, от прошлого прогона), повторный постмортем не запускается.
+func TestWorkerPostMortemNotRepeated(t *testing.T) {
+	s := setupWorkerDB(t)
+	task := createReadyTask(t, s, "pm-repeat")
+
+	ctx := context.Background()
+	if _, err := s.AppendTrace(ctx, &storage.Trace{
+		TaskID: task.ID,
+		Agent:  postMortemAgent,
+		Prompt: "старый анализ",
+		Output: "старое резюме",
+	}); err != nil {
+		t.Fatalf("seed postmortem trace: %v", err)
+	}
+
+	runner := &mockRunnerWorker{err: errors.New("opencode not found")}
+	w := &Worker{
+		Store:    s,
+		Runner:   runner,
+		Worktree: t.TempDir(),
+	}
+	seedFakeRepo(t, w.Worktree, "pm-repeat")
+
+	_ = w.runTask(ctx, task)
+
+	task, _ = s.GetTask(ctx, task.ID)
+	if task.Status != storage.StatusFailed {
+		t.Fatalf("status = %q, want failed", task.Status)
+	}
+	if runner.postMortemCount != 0 {
+		t.Errorf("postmortem запускался %d раз, want 0 (уже был trace)", runner.postMortemCount)
+	}
+	// количество postmortem-трасс не выросло
+	traces, _ := s.GetTraces(ctx, task.ID)
+	var pm int
+	for _, tr := range traces {
+		if tr.Agent == postMortemAgent {
+			pm++
+		}
+	}
+	if pm != 1 {
+		t.Errorf("postmortem-трасс = %d, want 1 (без дубля)", pm)
+	}
+}
+
+// TestWorkerPostMortemUsesTranscript — постмортем достаёт транскрипт dev-сессии
+// (по session_id) и вставляет шаги агента в промпт постмортем-агента.
+func TestWorkerPostMortemUsesTranscript(t *testing.T) {
+	s := setupWorkerDB(t)
+	task := createReadyTask(t, s, "pm-transcript")
+
+	runner := &mockRunnerWorker{
+		result: &opencode.Result{RC: -1, Stdout: "", SessionID: "sess-dev"},
+		sessionTranscripts: map[string]string{
+			"sess-dev": "[Инструмент]\nчитает requirements.md\n[Ассистент]\nправлю main.go",
+		},
+	}
+	w := &Worker{
+		Store:    s,
+		Runner:   runner,
+		Agent:    "dev",
+		Worktree: t.TempDir(),
+	}
+	seedFakeRepo(t, w.Worktree, "pm-transcript")
+
+	ctx := context.Background()
+	_ = w.runTask(ctx, task)
+
+	task, _ = s.GetTask(ctx, task.ID)
+	if task.Status != storage.StatusTimeout {
+		t.Fatalf("status = %q, want timeout", task.Status)
+	}
+
+	traces, err := s.GetTraces(ctx, task.ID)
+	if err != nil {
+		t.Fatalf("get traces: %v", err)
+	}
+	var pm *storage.Trace
+	for _, tr := range traces {
+		if tr.Agent == postMortemAgent {
+			pm = tr
+		}
+	}
+	if pm == nil {
+		t.Fatal("нет постмортем-трассы")
+	}
+	for _, want := range []string{"Транскрипт сессии", "читает requirements.md", "правлю main.go"} {
+		if !strings.Contains(pm.Prompt, want) {
+			t.Errorf("промпт постмортема не содержит %q", want)
+		}
+	}
+}
+
+// TestRenderPostMortemPrompt — промпт постмортема включает задачу, сессии и
+// транскрипт сессий (шаги агентов), а не только финальный вывод.
+func TestRenderPostMortemPrompt(t *testing.T) {
+	tr := storage.Trace{
+		Agent:     "dev",
+		Status:    storage.TraceTimeout,
+		SessionID: "sess-dev-1",
+		Prompt:    "промпт dev",
+		Output:    "вывод dev",
+	}
+	transcripts := map[string]string{
+		"sess-dev-1": "[Инструмент]\nпрочитал файл a.go\n[Ассистент]\nправлю код",
+	}
+	prompt, err := RenderPostMortemPrompt(PostMortemPromptData{
+		Title:    "Таймаут-задача",
+		Goal:     "сделать",
+		Repos:    []string{"calc"},
+		AC:       "работает",
+		Status:   storage.StatusTimeout,
+		Sessions: postMortemsText([]storage.Trace{tr}, transcripts),
+	})
+	if err != nil {
+		t.Fatalf("render: %v", err)
+	}
+	for _, want := range []string{
+		"Таймаут-задача", "timeout", "=== Агент: dev", "промпт dev", "вывод dev",
+		"Транскрипт сессии", "прочитал файл a.go", "правлю код",
+	} {
+		if !strings.Contains(prompt, want) {
+			t.Errorf("промпт не содержит %q", want)
+		}
+	}
+}
+
+// TestPostMortemsTextTranscriptUnavailable — сессия с session_id, для которой
+// транскрипт не загружен, помечается как недоступный, а не падает.
+func TestPostMortemsTextTranscriptUnavailable(t *testing.T) {
+	tr := storage.Trace{Agent: "reviewer", Status: storage.TraceFailed, SessionID: "sess-r"}
+	text := postMortemsText([]storage.Trace{tr}, nil)
+	if !strings.Contains(text, "транскрипт сессии недоступен") {
+		t.Errorf("нет пометки о недоступном транскрипте: %q", text)
+	}
+}
+
+// TestPostMortemsTextTranscriptEmpty — в сессии нет сообщений: агент не сделал
+// ни одного шага — это пишется явно, чтобы постмортем не строил догадок.
+func TestPostMortemsTextTranscriptEmpty(t *testing.T) {
+	tr := storage.Trace{Agent: "dev", Status: storage.TraceTimeout, SessionID: "sess-e"}
+	text := postMortemsText([]storage.Trace{tr}, map[string]string{"sess-e": ""})
+	if !strings.Contains(text, "не сделал ни одного шага") {
+		t.Errorf("нет пометки о пустой сессии: %q", text)
+	}
+}
+
+// TestFormatReviewVerdict — человекочитаемое описание вердикта ревьюера.
+func TestFormatReviewVerdict(t *testing.T) {
+	tests := []struct {
+		name string
+		v    *reviewVerdict
+		want []string
+	}{
+		{
+			name: "passed with everything",
+			v: &reviewVerdict{
+				Passed:          true,
+				CriticalIssues:  []string{"bug A"},
+				SolidViolations: []string{"v1", "v2"},
+				Comments:        []string{"comment"},
+			},
+			want: []string{"passed=yes", "critical=[bug A]", "solid=[v1 | v2]", "comments=[comment]"},
+		},
+		{
+			name: "failed with critical only",
+			v: &reviewVerdict{
+				Passed:         false,
+				CriticalIssues: []string{"bug A", "bug B"},
+			},
+			want: []string{"passed=no", "critical=[bug A | bug B]"},
+		},
+		{
+			name: "empty verdict",
+			v:    &reviewVerdict{},
+			want: []string{"passed=no"},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := formatReviewVerdict(tt.v)
+			for _, w := range tt.want {
+				if !strings.Contains(got, w) {
+					t.Errorf("formatReviewVerdict = %q, want contain %q", got, w)
+				}
+			}
+		})
+	}
+}