README.md

@@ -131,7 +131,7 @@ 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).
@@ -173,6 +173,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. Модель:

internal/agents/agents.go

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

internal/agents/postmortem.md

@@ -0,0 +1,28 @@
+---
+name: postmortem
+description: Постмортем-аналитик Ratatoskr — анализирует сессии dev/reviewer после failed/timeout задачи и даёт резюме: почему так и что сделать, чтобы не повторялось
+mode: primary
+---
+
+Ты — постмортем-аналитик в конвейере 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/app/app.go

@@ -53,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 {

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

@@ -24,9 +24,9 @@ import (
 // Prompt не блокирует: вердикт собирается поллингом из content[].type=="text"
 // новых assistant-сообщений (см. Runner.awaitVerdict).
 type Client struct {
-	BaseURL  string // http://host:port (без завершающего слеша)
-	Password string // basic auth (username "opencode")
-	Debug    bool   // включать отладочные логи API-вызовов (log.level=debug)
+	BaseURL  string       // http://host:port (без завершающего слеша)
+	Password string       // basic auth (username "opencode")
+	Debug    bool         // включать отладочные логи API-вызовов (log.level=debug)
 	http     *http.Client // единый клиент: все операции быстрые (нет блокирующего Send)
 }
 
@@ -63,7 +63,7 @@ func (c *Client) do(ctx context.Context, method, path, op string, body []byte) (
 		req.Header.Set("Content-Type", "application/json")
 	}
 	if c.Debug {
-		log.Printf("opencode api %s -> %s %s%s", op, method, c.BaseURL, path)
+		log.Printf("opencode api debug: %s -> %s %s%s", op, method, c.BaseURL, path)
 	}
 	resp, err := c.http.Do(req)
 	if err != nil {
@@ -76,12 +76,12 @@ func (c *Client) do(ctx context.Context, method, path, op string, body []byte) (
 	}
 	if resp.StatusCode < 200 || resp.StatusCode > 299 {
 		if c.Debug {
-			log.Printf("opencode api %s response: status %d", op, resp.StatusCode)
+			log.Printf("opencode api debug: %s response: status %d", op, resp.StatusCode)
 		}
 		return nil, &ClientErr{Op: op, Err: fmt.Errorf("status %d: %s", resp.StatusCode, truncateStr(string(b), 300))}
 	}
 	if c.Debug {
-		log.Printf("opencode api %s response (%d bytes)", op, len(b))
+		log.Printf("opencode api debug: %s response (%d bytes)", op, len(b))
 	}
 	return b, nil
 }
@@ -320,6 +320,26 @@ 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
+}
+
 func truncateStr(s string, n int) string {
 	if len(s) <= n {
 		return s

internal/opencode/client_test.go

@@ -25,10 +25,11 @@ type fakeAPIServer struct {
 	sessionID  string
 	created    bool
 	active     bool
-	blockPrompt bool
-	messages   []v2Message
-	verdictText string
-	failCreate  bool
+	blockPrompt  bool
+	messages     []v2Message
+	verdictText  string
+	verdictReasoning string // завершённый ответ только с reasoning-партом (без text)
+	failCreate   bool
 	failMessages bool
 	createdModel *ModelRef // модель, полученная на POST /api/session
 	promptCalls int
@@ -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)
@@ -279,6 +296,48 @@ func Test_newestAssistant(t *testing.T) {
 	}
 }
 
+func Test_assistantVerdict(t *testing.T) {
+	older := time.Now().Add(-time.Minute).UnixMilli()
+	newer := time.Now().UnixMilli()
+	reasoningOf := func(text string, at *int64) v2Message {
+		return v2Message{ID: "r", Type: "assistant", Content: []v2Part{{Type: "reasoning", Text: text}}, Time: v2Time{Created: at}}
+	}
+
+	// reasoning-only: text-партов нет → fallback на reasoning, usedReasoning=true.
+	// Сообщения приходят новейшими первыми (как из API) → размышление 2 новее.
+	reasoningOnlyMsgs := []v2Message{
+		reasoningOf("размышление 2", &newer),
+		reasoningOf("размышление 1", &older),
+	}
+	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)
+	}
+}
+
 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" {

internal/opencode/runner.go

@@ -216,10 +216,13 @@ func (r *Runner) verdict(model *ModelRef, cur *v2Message, msgs []v2Message, sinc
 	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

@@ -110,6 +110,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()

internal/worker/postmortem.go

@@ -0,0 +1,205 @@
+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
+
+// 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 в секцию промпта.
+func postMortemsText(traces []storage.Trace) 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 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)
+		}
+	}
+
+	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),
+	})
+	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 = "(постмортем-агент не вернул текст)"
+		}
+	}
+	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/worker.go

@@ -196,6 +196,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)

internal/worker/worker_test.go

@@ -54,6 +54,11 @@ type mockRunnerWorker struct {
 	// (последний вечный). Позволяет смоделировать fail-then-pass.
 	reviewSequence []*opencode.Result
 	reviewCount    int
+
+	// postMortemResult — результат постмортем-агента; nil → RC:0 с тестовым
+	// резюме. postMortemCount — сколько раз постмортем вызывался.
+	postMortemResult *opencode.Result
+	postMortemCount  int
 }
 
 func (m *mockRunnerWorker) Run(_ context.Context, _, _, agent, _ string) (*opencode.Result, error) {
@@ -71,6 +76,13 @@ 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
 }
 
@@ -402,12 +414,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 +436,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 +467,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 +499,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 +572,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 +595,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 +616,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 +639,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 +679,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 +688,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) {
@@ -882,3 +945,148 @@ 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)
+	}
+}
+
+// TestRenderPostMortemPrompt — промпт постмортема включает задачу и сессии.
+func TestRenderPostMortemPrompt(t *testing.T) {
+	tr := storage.Trace{
+		Agent:  "dev",
+		Status: storage.TraceTimeout,
+		Prompt: "промпт dev",
+		Output: "вывод dev",
+	}
+	prompt, err := RenderPostMortemPrompt(PostMortemPromptData{
+		Title:    "Таймаут-задача",
+		Goal:     "сделать",
+		Repos:    []string{"calc"},
+		AC:       "работает",
+		Status:   storage.StatusTimeout,
+		Sessions: postMortemsText([]storage.Trace{tr}),
+	})
+	if err != nil {
+		t.Fatalf("render: %v", err)
+	}
+	for _, want := range []string{"Таймаут-задача", "timeout", "=== Агент: dev", "промпт dev", "вывод dev"} {
+		if !strings.Contains(prompt, want) {
+			t.Errorf("промпт не содержит %q", want)
+		}
+	}
+}