From 963e7b478eca9ad4cce7ed90009f66f567261b81 Mon Sep 17 00:00:00 2001 From: "ki.sagidullin" Date: Sun, 23 Aug 2026 09:52:13 +0500 Subject: [PATCH] =?UTF-8?q?feat(worker):=20=D0=BF=D0=BE=D1=81=D1=82=D0=BC?= =?UTF-8?q?=D0=BE=D1=80=D1=82=D0=B5=D0=BC-=D0=B0=D0=BD=D0=B0=D0=BB=D0=B8?= =?UTF-8?q?=D0=B7=20=D0=BF=D0=BE=D1=81=D0=BB=D0=B5=20failed/timeout?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit После завершения задачи со статусом failed/timeout воркер запускает постмортем-анализ (агент postmortem): разбирает сессии dev/reviewer, оценивает причины сбоя и шлёт владельцу уведомление с анализом. Статус задачи не меняет; сбои анализа не влияют на исход. --- README.md | 14 +- internal/agents/agents.go | 2 +- internal/agents/postmortem.md | 28 ++++ internal/app/app.go | 2 +- internal/worker/postmortem.go | 205 +++++++++++++++++++++++++++ internal/worker/worker.go | 4 + internal/worker/worker_test.go | 250 ++++++++++++++++++++++++++++++--- 7 files changed, 481 insertions(+), 24 deletions(-) create mode 100644 internal/agents/postmortem.md create mode 100644 internal/worker/postmortem.go diff --git a/README.md b/README.md index 34b8f44..50661e9 100644 --- a/README.md +++ b/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. Модель: diff --git a/internal/agents/agents.go b/internal/agents/agents.go index 7e7d952..e356a41 100644 --- a/internal/agents/agents.go +++ b/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 // (создаёт его). Файлы перезаписываются — встроенная копия всегда актуальна. diff --git a/internal/agents/postmortem.md b/internal/agents/postmortem.md new file mode 100644 index 0000000..79b6563 --- /dev/null +++ b/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> \ No newline at end of file diff --git a/internal/app/app.go b/internal/app/app.go index 51a71ba..aae18e7 100644 --- a/internal/app/app.go +++ b/internal/app/app.go @@ -53,7 +53,7 @@ const packageOwner = "kamelion" // не следует путать с build-идентификатором `main.version` (commit-), // который вшивается ldflag'ом и используется автообновлением. Здесь номер // поднимается вручную перед каждым релизом/публикацией новой сборки. -const Version = "0.2.2" +const Version = "0.3.0" // App — собранный конвейер. type App struct { diff --git a/internal/worker/postmortem.go b/internal/worker/postmortem.go new file mode 100644 index 0000000..100b861 --- /dev/null +++ b/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) +} diff --git a/internal/worker/worker.go b/internal/worker/worker.go index 55b137d..9d4115d 100644 --- a/internal/worker/worker.go +++ b/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) diff --git a/internal/worker/worker_test.go b/internal/worker/worker_test.go index 37f08dd..ca04fd9 100644 --- a/internal/worker/worker_test.go +++ b/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) + } + } +}