feat(events): EventBus + domain-модель статусов

- internal/model: единый источник статусов задачи (Status, TraceStatus, машина переходов), без зависимости от storage. - internal/storage: совместимый мост (type Status = model.Status, re-export констант) — внешний код не меняется. - internal/events: шина событий (fan-out, блокирующий Publish с гарантией порядка), события задач/трейсов, отдельная логовая шина + LogWriter, Publisher/NilPublisher для внедрения в Core/Worker. - docs/ui-spec.md: спецификация десктопного UI (Fyne).
2026-08-20 01:02:31 +05:00
parent 408d137747
commit 1f7ab9a67e
10 changed files with 764 additions and 54 deletions
--- a/internal/events/bus.go
+++ b/internal/events/bus.go
@@ -0,0 +1,110 @@
+// Package events — шина событий для обмена UI ↔ Core.
+//
+// Две независимые шины: доменная (статусы задач, история, трейсы) и логовая
+// (сырые строки лога для панели «Логи»). Обе построены на одном типе *Bus,
+// DOMAIN шина блокирующая (гарантия доставки и порядка), логовая — та же,
+// но с большим буфером, чтобы не тормозить логирование.
+package events
+
+import (
+	"sync"
+)
+
+// Event — доменное событие. Закрытый интерфейс: новые типы добавляются
+// только внутри пакета.
+type Event interface {
+	_event()
+}
+
+// Bus — широковещательная шина событий (fan-out).
+//
+// Publish блокирует вызывающую горутину до тех пор, пока все подписчики не
+// получат событие (в копию их буфера). Порядок событий для каждого
+// подписчика сохраняется. Удаление подписчика происходит горутиной-монтируется
+// close(done), что снимает блокировку Publish.
+type Bus struct {
+	bufSize int
+
+	mu   sync.RWMutex
+	subs map[*subscriber]struct{}
+}
+
+type subscriber struct {
+	ch   chan Event
+	done chan struct{}
+}
+
+// New создаёт шину с буфером bufSize на каждого подписчика.
+func New(bufSize int) *Bus {
+	if bufSize < 1 {
+		bufSize = 1
+	}
+	return &Bus{
+		bufSize: bufSize,
+		subs:    make(map[*subscriber]struct{}),
+	}
+}
+
+// Subscribe регистрирует нового подписчика и возвращает канал событий вместе
+// с функцией отписки. Рекомендуемый паттерн потребления:
+//
+//	ch, unsub := bus.Subscribe()
+//	defer unsub()
+//	for {
+//	    select {
+//	    case e := <-ch:
+//	        switch ev := e.(type) { ... }
+//	    case <-closeCh:
+//	        return
+//	    }
+//	}
+//
+// Канал не закрывается шиной: выход из горутины подписчика организуется через
+// закрытие канала приложения либо другого сигнала в select.
+func (b *Bus) Subscribe() (<-chan Event, func()) {
+	s := &subscriber{
+		ch:   make(chan Event, b.bufSize),
+		done: make(chan struct{}),
+	}
+
+	b.mu.Lock()
+	b.subs[s] = struct{}{}
+	b.mu.Unlock()
+
+	var once sync.Once
+	unsubscribe := func() {
+		once.Do(func() {
+			close(s.done)
+			b.mu.Lock()
+			delete(b.subs, s)
+			b.mu.Unlock()
+		})
+	}
+	return s.ch, unsubscribe
+}
+
+// Publish рассылает событие всем подписчикам и блокируется, пока каждый
+// подписчик либо примет событие (в свой буфер), либо отпишется. Порядок
+// рассылки стабилен (по списку подписок). Безопасен для Concurrent вызовов.
+func (b *Bus) Publish(e Event) {
+	b.mu.RLock()
+	subs := make([]*subscriber, 0, len(b.subs))
+	for s := range b.subs {
+		subs = append(subs, s)
+	}
+	b.mu.RUnlock()
+
+	for _, s := range subs {
+		select {
+		case s.ch <- e:
+		case <-s.done:
+		}
+	}
+}
+
+// SubscribersCount — число активных подписчиков (для юнит-тестов и отладки).
+func (b *Bus) SubscribersCount() int {
+	b.mu.RLock()
+	defer b.mu.RUnlock()
+	return len(b.subs)
+}
--- a/internal/events/bus_test.go
+++ b/internal/events/bus_test.go
@@ -0,0 +1,119 @@
+package events
+
+import (
+	"testing"
+	"time"
+
+	"github.com/kamelion/ratatoskr-go/internal/model"
+)
+
+// receiveOne помогает получить одно событие с таймаутом.
+func receiveOne(t *testing.T, ch <-chan Event) Event {
+	t.Helper()
+	select {
+	case e := <-ch:
+		return e
+	case <-time.After(2 * time.Second):
+		t.Fatal("timeout waiting for event")
+		return nil
+	}
+}
+
+func TestBusPublishToSubscriber(t *testing.T) {
+	bus := New(10)
+	ch, unsub := bus.Subscribe()
+	defer unsub()
+
+	want := TaskStatusChanged{ID: 42, From: model.StatusReady, To: model.StatusRunning}
+	bus.Publish(want)
+
+	got := receiveOne(t, ch)
+	ev, ok := got.(TaskStatusChanged)
+	if !ok {
+		t.Fatalf("got %T, want TaskStatusChanged", got)
+	}
+	if ev.ID != 42 || ev.From != model.StatusReady || ev.To != model.StatusRunning {
+		t.Fatalf("unexpected event: %+v", ev)
+	}
+}
+
+func TestBusFanout(t *testing.T) {
+	bus := New(10)
+	ch1, unsub1 := bus.Subscribe()
+	defer unsub1()
+	ch2, unsub2 := bus.Subscribe()
+	defer unsub2()
+
+	e := LogLine{Level: "log", Text: "hello"}
+	bus.Publish(e)
+
+	if got := receiveOne(t, ch1); got != e {
+		t.Fatalf("subscriber 1 got %#v, want %#v", got, e)
+	}
+	if got := receiveOne(t, ch2); got != e {
+		t.Fatalf("subscriber 2 got %#v, want %#v", got, e)
+	}
+}
+
+func TestBusPreservesOrder(t *testing.T) {
+	bus := New(64)
+	ch, unsub := bus.Subscribe()
+	defer unsub()
+
+	const n = 25
+	for i := 0; i < n; i++ {
+		bus.Publish(TraceAppended{TaskID: int64(i)})
+	}
+	for i := 0; i < n; i++ {
+		ev := receiveOne(t, ch)
+		ta, ok := ev.(TraceAppended)
+		if !ok {
+			t.Fatalf("got %T, want TraceAppended", ev)
+		}
+		if ta.TaskID != int64(i) {
+			t.Fatalf("out of order: got %d, want %d", ta.TaskID, i)
+		}
+	}
+}
+
+func TestUnsubscribeStopsDelivery(t *testing.T) {
+	bus := New(10)
+	ch, unsub := bus.Subscribe()
+	bus.Publish(TaskCreated{ID: 1})
+	receiveOne(t, ch)
+
+	unsub()
+	if got := bus.SubscribersCount(); got != 0 {
+		t.Fatalf("SubscribersCount = %d, want 0", got)
+	}
+
+	// Убеждаемся, что Publish не блокируется навечно отписанным подписчиком.
+	bus.Publish(TaskCreated{ID: 2})
+
+	select {
+	case got := <-ch:
+		t.Fatalf("received %#v after unsubscribe", got)
+	case <-time.After(200 * time.Millisecond):
+	}
+}
+
+func TestBusSubscribersCount(t *testing.T) {
+	bus := New(10)
+	if got := bus.SubscribersCount(); got != 0 {
+		t.Fatalf("initial count = %d, want 0", got)
+	}
+	_, unsub1 := bus.Subscribe()
+	_, unsub2 := bus.Subscribe()
+	if got := bus.SubscribersCount(); got != 2 {
+		t.Fatalf("count = %d, want 2", got)
+	}
+	unsub1()
+	unsub2()
+	if got := bus.SubscribersCount(); got != 0 {
+		t.Fatalf("after unsub count = %d, want 0", got)
+	}
+}
+
+func TestNilPublisherNoOp(t *testing.T) {
+	NilPublisher{}.Publish(TaskCreated{ID: 1}) // must not panic
+}
--- a/internal/events/events.go
+++ b/internal/events/events.go
@@ -0,0 +1,56 @@
+package events
+
+import "github.com/kamelion/ratatoskr-go/internal/model"
+
+// TaskCreated — создана новая задача.
+type TaskCreated struct {
+	ID     int64
+	ChatID string
+	Title  string
+}
+
+// TaskUpdated — задача изменена (поля, права, репозитории).
+type TaskUpdated struct {
+	ID int64
+}
+
+// TaskDeleted — задача удалена.
+type TaskDeleted struct {
+	ID int64
+}
+
+// TaskStatusChanged — статус задачи изменился (переход из From в To).
+type TaskStatusChanged struct {
+	ID   int64
+	From model.Status
+	To   model.Status
+}
+
+// HistoryAppended — добавлено сообщение в историю задачи.
+type HistoryAppended struct {
+	TaskID  int64
+	Role    string // user | assistant | реплика события
+	Content string
+}
+
+// TraceAppended — добавлен/обновлён трейс субагента.
+type TraceAppended struct {
+	TaskID int64
+	Agent  string
+	Status model.TraceStatus
+}
+
+// AgentActivity — смена этапа работы агента (для анимации «состояния»).
+type AgentActivity struct {
+	TaskID int64
+	Agent  string
+	Stage  string
+}
+
+func (TaskCreated) _event()      {}
+func (TaskUpdated) _event()      {}
+func (TaskDeleted) _event()      {}
+func (TaskStatusChanged) _event() {}
+func (HistoryAppended) _event()  {}
+func (TraceAppended) _event()    {}
+func (AgentActivity) _event()    {}
--- a/internal/events/log.go
+++ b/internal/events/log.go
@@ -0,0 +1,65 @@
+package events
+
+import (
+	"strings"
+	"sync"
+)
+
+// LogLine — строка лога для панели «Логи».
+type LogLine struct {
+	Level string
+	Text  string
+}
+
+func (LogLine) _event() {}
+
+// LogBus — тип-обёртка над *Bus для логов.
+//
+// Логи идут отдельной шиной, чтобы большие объёмы текста не блокировали
+// доменные события и наоборот.
+type LogBus struct {
+	*Bus
+}
+
+// NewLogBus создаёт шину логов с буфером на подписчика.
+func NewLogBus(bufSize int) *LogBus {
+	return &LogBus{Bus: New(bufSize)}
+}
+
+// LogWriter — io.Writer, который публикует каждую строку лога как LogLine.
+// Предполагается использование через log.SetOutput в связке, чтобы всё
+// логирование приложения попадало и в панель «Логи».
+type LogWriter struct {
+	bus *Bus
+	mu  sync.Mutex // защищает остаток частичной строки
+	buf strings.Builder
+}
+
+// NewLogWriter создаёт LogWriter, публикующий в шину логов события LogLine{Level:"log"}.
+func NewLogWriter(bus *LogBus) *LogWriter {
+	return &LogWriter{bus: bus.Bus}
+}
+
+// Write реализует io.Writer. Данные разрезаются по переводам строки:
+// каждая законченная строка публикуется отдельным событием.
+func (w *LogWriter) Write(p []byte) (int, error) {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+
+	w.buf.Write(p)
+	data := w.buf.String()
+	for {
+		idx := strings.IndexByte(data, '\n')
+		if idx < 0 {
+			break
+		}
+		line := strings.TrimSuffix(data[:idx], "\r")
+		data = data[idx+1:]
+		if line != "" {
+			w.bus.Publish(LogLine{Level: "log", Text: line})
+		}
+	}
+	w.buf.Reset()
+	w.buf.WriteString(data)
+	return len(p), nil
+}
--- a/internal/events/log_test.go
+++ b/internal/events/log_test.go
@@ -0,0 +1,76 @@
+package events
+
+import (
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestLogWriterLines(t *testing.T) {
+	lbus := NewLogBus(16)
+	ch, unsub := lbus.Subscribe()
+	defer unsub()
+
+	w := NewLogWriter(lbus)
+	if _, err := w.Write([]byte("first line\nsecond line\n")); err != nil {
+		t.Fatalf("Write: %v", err)
+	}
+
+	first := receiveOne(t, ch)
+	ll, ok := first.(LogLine)
+	if !ok {
+		t.Fatalf("got %T, want LogLine", first)
+	}
+	if ll.Text != "first line" || ll.Level != "log" {
+		t.Fatalf("unexpected first line: %+v", ll)
+	}
+
+	second := receiveOne(t, ch)
+	if ll, ok := second.(LogLine); !ok || ll.Text != "second line" {
+		t.Fatalf("unexpected second line: %+v", second)
+	}
+}
+
+func TestLogWriterPartialLine(t *testing.T) {
+	lbus := NewLogBus(16)
+	ch, unsub := lbus.Subscribe()
+	defer unsub()
+
+	w := NewLogWriter(lbus)
+	if _, err := w.Write([]byte("partial")); err != nil {
+		t.Fatalf("Write: %v", err)
+	}
+	select {
+	case got := <-ch:
+		t.Fatalf("partial line should not be published yet, got %#v", got)
+	case <-time.After(150 * time.Millisecond):
+	}
+
+	if _, err := w.Write([]byte(" line\n")); err != nil {
+		t.Fatalf("Write: %v", err)
+	}
+	got := receiveOne(t, ch)
+	ll, ok := got.(LogLine)
+	if !ok || ll.Text != "partial line" {
+		t.Fatalf("unexpected: %#v", got)
+	}
+}
+
+func TestLogWriterMultiSplit(t *testing.T) {
+	lbus := NewLogBus(16)
+	ch, unsub := lbus.Subscribe()
+	defer unsub()
+
+	w := NewLogWriter(lbus)
+	if _, err := w.Write([]byte("line1\nline2\nline3\n")); err != nil {
+		t.Fatalf("Write: %v", err)
+	}
+	var texts []string
+	for i := 0; i < 3; i++ {
+		ev := receiveOne(t, ch)
+		texts = append(texts, ev.(LogLine).Text)
+	}
+	if strings.Join(texts, ",") != "line1,line2,line3" {
+		t.Fatalf("got %v", texts)
+	}
+}
--- a/internal/events/publisher.go
+++ b/internal/events/publisher.go
@@ -0,0 +1,20 @@
+package events
+
+// Publisher — минимальный интерфейс для встраивания шины в Core/Worker/Analyst.
+//
+// Core публикует доменные события через него; конкретная шина подставляется
+// при сборке приложения. На время тестов или до создания UI можно
+// использовать NilPublisher — безопасную no-op реализацию.
+type Publisher interface {
+	Publish(e Event)
+}
+
+// NilPublisher — no-op издатель, чтобы компоненты могли работать без UI.
+type NilPublisher struct{}
+
+// Publish ничего не делает (совместимо с Publisher).
+func (NilPublisher) Publish(Event) {}
+
+// CompileTime-проверка: *Bus реализует Publisher.
+var _ Publisher = (*Bus)(nil)
+var _ Publisher = NilPublisher{}
--- a/internal/model/status.go
+++ b/internal/model/status.go
@@ -0,0 +1,77 @@
+// Package model — доменные типы и контракты Ratatoskr.
+//
+// Нижний слой архитектуры: не зависит ни от БД (storage), ни от UI (events).
+// Хранит семантику предметной области (статусы задач, машина переходов),
+// чтобы storage и events зависели только от этой модели, а не друг от друга.
+package model
+
+// Status — статус задачи (state machine).
+type Status string
+
+const (
+	StatusDraft       Status = "draft"        // только что создана
+	StatusCollecting  Status = "collecting"    // аналитик собирает детали
+	StatusReady       Status = "ready"         // черновик готов, ждёт одобрения пользователя
+	StatusApproved    Status = "approved"      // пользователь одобрил («создавай») — воркер берёт в работу
+	StatusRunning     Status = "running"       // opencode работает
+	StatusSuccess     Status = "success"       // задача выполнена
+	StatusFailed      Status = "failed"        // ошибка выполнения
+	StatusTimeout     Status = "timeout"       // таймаут opencode
+	StatusCancelled   Status = "cancelled"     // отменена пользователем
+	StatusAborted     Status = "aborted"       // сбой сбора, черновик выброшен
+	StatusClosed      Status = "closed"        // закрыта вручную
+)
+
+// AllStatuses — все возможные статусы для валидации.
+var AllStatuses = []Status{
+	StatusDraft, StatusCollecting, StatusReady, StatusApproved,
+	StatusRunning, StatusSuccess, StatusFailed, StatusTimeout,
+	StatusCancelled, StatusAborted, StatusClosed,
+}
+
+// validTransitions задаёт разрешённые переходы статусов.
+var validTransitions = map[Status][]Status{
+	StatusDraft:      {StatusCollecting, StatusCancelled, StatusAborted},
+	StatusCollecting: {StatusReady, StatusDraft, StatusCancelled, StatusAborted},
+	// ready — черновик готов: «создавай» → approved, либо правка/отмена/закрытие.
+	StatusReady: {StatusApproved, StatusCancelled, StatusAborted, StatusClosed, StatusCollecting},
+	// approved — финальное одобрение: воркер берёт в running, либо отмена/сбой/закрытие.
+	StatusApproved: {StatusRunning, StatusCancelled, StatusAborted, StatusClosed},
+	StatusRunning:  {StatusSuccess, StatusFailed, StatusTimeout, StatusCancelled},
+	StatusSuccess:  {StatusClosed},
+	StatusFailed:   {StatusReady, StatusClosed, StatusCancelled, StatusCollecting}, // retry: перезапуск сбора
+	StatusTimeout:  {StatusReady, StatusClosed, StatusCancelled, StatusCollecting}, // retry: перезапуск сбора
+	StatusCancelled: {StatusClosed},
+	StatusAborted:   {StatusClosed},
+	StatusClosed:    {}, // терминальный
+}
+
+// IsValidTransition проверяет, допустим ли переход from → to.
+func IsValidTransition(from, to Status) bool {
+	allowed, ok := validTransitions[from]
+	if !ok {
+		return false
+	}
+	for _, s := range allowed {
+		if s == to {
+			return true
+		}
+	}
+	return false
+}
+
+// IsTerminal возвращает true, если статус терминальный.
+func IsTerminal(s Status) bool {
+	return s == StatusSuccess || s == StatusCancelled ||
+		s == StatusAborted || s == StatusClosed
+}
+
+// TraceStatus — статус трассировки субагента.
+type TraceStatus string
+
+const (
+	TraceRunning TraceStatus = "running"
+	TraceSuccess TraceStatus = "success"
+	TraceFailed  TraceStatus = "failed"
+	TraceTimeout TraceStatus = "timeout"
+)
--- a/internal/model/status_test.go
+++ b/internal/model/status_test.go
@@ -0,0 +1,50 @@
+package model
+
+import "testing"
+
+func TestValidTransitions(t *testing.T) {
+	cases := []struct {
+		from, to Status
+		want     bool
+	}{
+		{StatusDraft, StatusCollecting, true},
+		{StatusDraft, StatusRunning, false},
+		{StatusReady, StatusApproved, true},
+		{StatusApproved, StatusRunning, true},
+		{StatusRunning, StatusSuccess, true},
+		{StatusRunning, StatusClosed, false},
+		{StatusSuccess, StatusClosed, true},
+		{StatusClosed, StatusDraft, false},
+	}
+
+	for _, c := range cases {
+		if got := IsValidTransition(c.from, c.to); got != c.want {
+			t.Errorf("IsValidTransition(%q, %q) = %v, want %v", c.from, c.to, got, c.want)
+		}
+	}
+}
+
+func TestIsTerminal(t *testing.T) {
+	terminal := []Status{StatusSuccess, StatusCancelled, StatusAborted, StatusClosed}
+	for _, s := range terminal {
+		if !IsTerminal(s) {
+			t.Errorf("IsTerminal(%q) = false, want true", s)
+		}
+	}
+	nonTerminal := []Status{StatusDraft, StatusReady, StatusRunning, StatusCollecting, StatusApproved, StatusFailed, StatusTimeout}
+	for _, s := range nonTerminal {
+		if IsTerminal(s) {
+			t.Errorf("IsTerminal(%q) = true, want false", s)
+		}
+	}
+}
+
+func TestAllStatusesCoverage(t *testing.T) {
+	seen := make(map[Status]bool)
+	for _, s := range AllStatuses {
+		seen[s] = true
+	}
+	if len(seen) != 11 {
+		t.Fatalf("AllStatuses has %d unique statuses, want 11", len(seen))
+	}
+}
--- a/internal/storage/models.go
+++ b/internal/storage/models.go
@@ -1,66 +1,43 @@
 package storage

-import "encoding/json"
+import (
+	"encoding/json"

-// Status — статус задачи (state machine).
-type Status string
+	"github.com/kamelion/ratatoskr-go/internal/model"
+)

+// Status — алиас доменного статуса задачи.
+//
+// Совместимый мост: весь внешний код продолжает использовать storage.Status
+// (например «storage.StatusRunning»), но единый источник истины — model.Status.
+type Status = model.Status
+
+// Статусы задачи — re-export из model.
 const (
-	StatusDraft       Status = "draft"        // только что создана
-	StatusCollecting  Status = "collecting"    // аналитик собирает детали
-	StatusReady       Status = "ready"         // черновик готов, ждёт одобрения пользователя
-	StatusApproved    Status = "approved"      // пользователь одобрил («создавай») — воркер берёт в работу
-	StatusRunning     Status = "running"       // opencode работает
-	StatusSuccess     Status = "success"       // задача выполнена
-	StatusFailed      Status = "failed"        // ошибка выполнения
-	StatusTimeout     Status = "timeout"       // таймаут opencode
-	StatusCancelled   Status = "cancelled"     // отменена пользователем
-	StatusAborted     Status = "aborted"       // сбой сбора, черновик выброшен
-	StatusClosed      Status = "closed"        // закрыта вручную
+	StatusDraft       = model.StatusDraft
+	StatusCollecting  = model.StatusCollecting
+	StatusReady       = model.StatusReady
+	StatusApproved    = model.StatusApproved
+	StatusRunning     = model.StatusRunning
+	StatusSuccess     = model.StatusSuccess
+	StatusFailed      = model.StatusFailed
+	StatusTimeout     = model.StatusTimeout
+	StatusCancelled   = model.StatusCancelled
+	StatusAborted     = model.StatusAborted
+	StatusClosed      = model.StatusClosed
 )

 // AllStatuses — все возможные статусы для валидации.
-var AllStatuses = []Status{
-	StatusDraft, StatusCollecting, StatusReady, StatusApproved,
-	StatusRunning, StatusSuccess, StatusFailed, StatusTimeout,
-	StatusCancelled, StatusAborted, StatusClosed,
-}
-
-// validTransitions задаёт разрешённые переходы статусов.
-var validTransitions = map[Status][]Status{
-	StatusDraft:      {StatusCollecting, StatusCancelled, StatusAborted},
-	StatusCollecting: {StatusReady, StatusDraft, StatusCancelled, StatusAborted},
-	// ready — черновик готов: «создавай» → approved, либо правка/отмена/закрытие.
-	StatusReady: {StatusApproved, StatusCancelled, StatusAborted, StatusClosed, StatusCollecting},
-	// approved — финальное одобрение: воркер берёт в running, либо отмена/сбой/закрытие.
-	StatusApproved: {StatusRunning, StatusCancelled, StatusAborted, StatusClosed},
-	StatusRunning:  {StatusSuccess, StatusFailed, StatusTimeout, StatusCancelled},
-	StatusSuccess:  {StatusClosed},
-	StatusFailed:   {StatusReady, StatusClosed, StatusCancelled, StatusCollecting}, // retry: перезапуск сбора
-	StatusTimeout:  {StatusReady, StatusClosed, StatusCancelled, StatusCollecting}, // retry: перезапуск сбора
-	StatusCancelled: {StatusClosed},
-	StatusAborted:   {StatusClosed},
-	StatusClosed:    {}, // терминальный
-}
+var AllStatuses = model.AllStatuses

 // IsValidTransition проверяет, допустим ли переход from → to.
 func IsValidTransition(from, to Status) bool {
-	allowed, ok := validTransitions[from]
-	if !ok {
-		return false
-	}
-	for _, s := range allowed {
-		if s == to {
-			return true
-		}
-	}
-	return false
+	return model.IsValidTransition(from, to)
 }

 // IsTerminal возвращает true, если статус терминальный.
 func IsTerminal(s Status) bool {
-	return s == StatusSuccess || s == StatusCancelled ||
-		s == StatusAborted || s == StatusClosed
+	return model.IsTerminal(s)
 }

 // Task — запись задачи в БД.
@@ -111,14 +88,14 @@ func (t *Task) SetReposFromDB(repos string) {
 	_ = json.Unmarshal([]byte(repos), &t.Repos)
 }

-// Trace — запись трассировки выполнения.
-type TraceStatus string
+// TraceStatus — алиас доменного статуса трассировки.
+type TraceStatus = model.TraceStatus

 const (
-	TraceRunning TraceStatus = "running"
-	TraceSuccess TraceStatus = "success"
-	TraceFailed  TraceStatus = "failed"
-	TraceTimeout TraceStatus = "timeout"
+	TraceRunning TraceStatus = model.TraceRunning
+	TraceSuccess TraceStatus = model.TraceSuccess
+	TraceFailed  TraceStatus = model.TraceFailed
+	TraceTimeout TraceStatus = model.TraceTimeout
 )

 // Trace — лог одного субагента.