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/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]
+	// где-то в списке есть уведомление о failed с упоминанием лимита итераций
-	if !strings.Contains(last, "failed") {
+	// (над ним — уведомление postmortem, поэтому последним оно не обязано быть).
-		t.Errorf("последнее уведомление = %q, want упоминание failed", last)
+	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) {
+	if !reflect.DeepEqual(texts[:2], want) {
-		t.Errorf("уведомления = %#v, want %#v", got, 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) {
+	if !reflect.DeepEqual(texts[:2], want) {
-		t.Errorf("уведомления = %#v, want %#v", got, 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 {
+	if len(traces) != 2 {
-		t.Fatalf("got %d traces, want 1", len(traces))
+		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 {
+	if len(traces) != 2 {
-		t.Fatalf("got %d traces, want 1", len(traces))
+		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 {
+	if len(traces) != 2 {
-		t.Fatalf("got %d traces, want 1", len(traces))
+		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)
+		}
+	}
+}