внутренняя модель перестроена вокруг аудиозаписи

- audiorecords вместо transcribe_jobs: приложения (texts, structures,
  recognitions, record_events, topics) живут своими коллекциями, ссылки на
  исходник и на приведённую копию перестали переставляться
- рубеж называет достигнутое, отказ стал признаком остановки с причиной, а
  сторожей стало двое: число отказов и время в рубеже
- воркеры потеряли специализацию, их число задаётся [pipeline] workers, шаг
  выбирается по рубежу, а захват отдаёт идентификатор и признак захвата

internal/adapter/recognizer/memory.go

@@ -2,22 +2,79 @@ package recognizer
 
 import (
 	"context"
+	"encoding/json"
+	"errors"
 	"io"
 
-	"git.vakhrushev.me/av/transcriber/internal/entity"
 	"github.com/google/uuid"
+
+	"git.vakhrushev.me/av/transcriber/internal/entity"
 )
 
+// MemoryAudioRecognizer — подставной распознаватель для местного запуска и
+// проверок. Прогон на реальных ключах ради проверки кода запрещён: распознавание
+// и хранение в Object Storage оплачиваются по факту.
+//
+// Сырой ответ он отдаёт своего вида, но настоящего: тем же путём, что и живой
+// адаптер, — сохранённые байты разбираются обратно в реплики, и структура
+// строится без единого обращения наружу.
 type MemoryAudioRecognizer struct{}
 
-func (r *MemoryAudioRecognizer) Recognize(ctx context.Context, file io.Reader, fileName string) (operationID string, err error) {
+const memoryProvider = "memory"
+
+func (r *MemoryAudioRecognizer) Provider() string { return memoryProvider }
+
+func (r *MemoryAudioRecognizer) Model() string { return "memory" }
+
+func (r *MemoryAudioRecognizer) Upload(ctx context.Context, file io.Reader, objectKey string) (string, error) {
+	return "memory://" + objectKey, nil
+}
+
+func (r *MemoryAudioRecognizer) ObjectExists(ctx context.Context, objectKey string, size int64) (bool, error) {
+	return false, nil
+}
+
+func (r *MemoryAudioRecognizer) Submit(ctx context.Context, sourceURI string) (string, error) {
 	return uuid.NewString(), nil
 }
 
-func (r *MemoryAudioRecognizer) GetRecognitionText(ctx context.Context, operationID string) (string, error) {
-	return "Foo bar, Baz.", nil
-}
-
-func (r *MemoryAudioRecognizer) CheckRecognitionStatus(ctx context.Context, operationID string) (*entity.RecognitionResult, error) {
+func (r *MemoryAudioRecognizer) CheckStatus(ctx context.Context, operationID string) (*entity.RecognitionResult, error) {
 	return entity.NewCompletedResult(), nil
 }
+
+func (r *MemoryAudioRecognizer) Fetch(ctx context.Context, operationID string) (*entity.RecognitionOutcome, error) {
+	replicas := []entity.Replica{
+		{StartMs: 0, EndMs: 1000, Text: "Foo bar,"},
+		{StartMs: 1000, EndMs: 2000, Text: "Baz."},
+	}
+	raw, err := json.Marshal(replicas)
+	if err != nil {
+		return nil, errors.New("failed to encode memory payload")
+	}
+	return &entity.RecognitionOutcome{
+		Replicas:  replicas,
+		PlainText: "Foo bar, Baz.",
+		Raw:       raw,
+	}, nil
+}
+
+func (r *MemoryAudioRecognizer) Parse(raw []byte) (*entity.RecognitionOutcome, error) {
+	var replicas []entity.Replica
+	if err := json.Unmarshal(raw, &replicas); err != nil {
+		return nil, errors.New("failed to decode memory payload")
+	}
+
+	var plain []byte
+	for _, replica := range replicas {
+		if len(plain) > 0 {
+			plain = append(plain, ' ')
+		}
+		plain = append(plain, replica.Text...)
+	}
+
+	return &entity.RecognitionOutcome{
+		Replicas:  replicas,
+		PlainText: string(plain),
+		Raw:       raw,
+	}, nil
+}

internal/adapter/recognizer/yandex/payload_test.go

@@ -0,0 +1,138 @@
+package yandex
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	stt "github.com/yandex-cloud/go-genproto/yandex/cloud/ai/stt/v3"
+	"google.golang.org/protobuf/proto"
+)
+
+// Сохранённый ответ провайдера — единственное, из чего пересчитывается архив:
+// результат операции у SpeechKit не переспрашивается, и повторное распознавание
+// стоит денег. Поэтому проверки ниже судят не «разбор чего-то вернул», а
+// сохранность самого ответа.
+
+// response собирает ответ потока с одной репликой.
+func response(text string, start, end int64) *stt.StreamingResponse {
+	return &stt.StreamingResponse{
+		Event: &stt.StreamingResponse_FinalRefinement{
+			FinalRefinement: &stt.FinalRefinement{
+				Type: &stt.FinalRefinement_NormalizedText{
+					NormalizedText: &stt.AlternativeUpdate{
+						Alternatives: []*stt.Alternative{
+							{Text: text, StartTimeMs: start, EndTimeMs: end},
+						},
+					},
+				},
+			},
+		},
+	}
+}
+
+// Сохранённое читается обратно тем же: реплики со временем и плоский текст.
+func TestPayloadSurvivesRoundTrip(t *testing.T) {
+	responses := []*stt.StreamingResponse{
+		response("Первая реплика.", 0, 900),
+		response("Вторая реплика.", 900, 1800),
+	}
+
+	raw, err := encodeResponses(responses)
+	require.NoError(t, err)
+	require.NotEmpty(t, raw)
+
+	decoded, err := decodeResponses(raw)
+	require.NoError(t, err)
+	require.Len(t, decoded, 2)
+
+	outcome := outcomeFromResponses(decoded)
+	require.Len(t, outcome.Replicas, 2)
+	assert.Equal(t, "Первая реплика.", outcome.Replicas[0].Text)
+	assert.Equal(t, int64(0), outcome.Replicas[0].StartMs)
+	assert.Equal(t, int64(900), outcome.Replicas[0].EndMs)
+	assert.Equal(t, "Вторая реплика.", outcome.Replicas[1].Text)
+	assert.Equal(t, "Первая реплика. Вторая реплика.", outcome.PlainText)
+}
+
+// Ради этого свойства сохранение и сделано двоичным. Провайдер добавляет поля
+// без предупреждения, и текстовое представление, собранное по нашей
+// скомпилированной схеме, выбросило бы их молча — а пересчитать архив было бы
+// уже не из чего: операция не переспрашивается.
+func TestUnknownProviderFieldSurvivesStorage(t *testing.T) {
+	original := response("Реплика.", 0, 500)
+
+	// Так выглядит поле, которого наша схема не знает: провайдер прислал его,
+	// разбор положил в неизвестные.
+	unknown := protoimplUnknown(t)
+	original.ProtoReflect().SetUnknown(unknown)
+	require.NotEmpty(t, original.ProtoReflect().GetUnknown(), "неизвестное поле поставлено")
+
+	raw, err := encodeResponses([]*stt.StreamingResponse{original})
+	require.NoError(t, err)
+
+	decoded, err := decodeResponses(raw)
+	require.NoError(t, err)
+	require.Len(t, decoded, 1)
+
+	assert.Equal(t, []byte(unknown), []byte(decoded[0].ProtoReflect().GetUnknown()),
+		"неизвестное провайдерское поле пережило запись и чтение")
+
+	// И известное при этом на месте.
+	outcome := outcomeFromResponses(decoded)
+	require.Len(t, outcome.Replicas, 1)
+	assert.Equal(t, "Реплика.", outcome.Replicas[0].Text)
+}
+
+// Обрезанное вложение узнаётся отказом, а не половиной расшифровки: половина
+// текста, выданная за целую, тише и хуже отказа.
+func TestTruncatedPayloadIsRefused(t *testing.T) {
+	raw, err := encodeResponses([]*stt.StreamingResponse{response("Реплика.", 0, 500)})
+	require.NoError(t, err)
+	require.Greater(t, len(raw), 2)
+
+	_, err = decodeResponses(raw[:len(raw)-2])
+	assert.Error(t, err, "обрезанное вложение не разбирается молча")
+}
+
+// Пустой поток даёт пустой результат, а не отказ: «на записи нет текста» —
+// законный исход распознавания.
+func TestEmptyStreamGivesEmptyOutcome(t *testing.T) {
+	raw, err := encodeResponses(nil)
+	require.NoError(t, err)
+
+	decoded, err := decodeResponses(raw)
+	require.NoError(t, err)
+	assert.Empty(t, decoded)
+
+	outcome := outcomeFromResponses(decoded)
+	assert.Empty(t, outcome.Replicas)
+	assert.Empty(t, outcome.PlainText)
+}
+
+// Ответ без разбора текста реплик не даёт и разбор не роняет: провайдер шлёт по
+// потоку и служебные события.
+func TestResponseWithoutTextIsSkipped(t *testing.T) {
+	responses := []*stt.StreamingResponse{
+		{Event: &stt.StreamingResponse_FinalRefinement{FinalRefinement: &stt.FinalRefinement{}}},
+		response("Реплика.", 0, 500),
+		response("", 500, 600),
+	}
+
+	outcome := outcomeFromResponses(responses)
+	require.Len(t, outcome.Replicas, 1, "пустые и служебные события репликами не становятся")
+	assert.Equal(t, "Реплика.", outcome.PlainText)
+}
+
+// protoimplUnknown собирает байты неизвестного поля: номер поля, которого в
+// нашей схеме нет, с целочисленным значением.
+func protoimplUnknown(t *testing.T) []byte {
+	t.Helper()
+
+	// Поле 4095, тип varint, значение 7 — заведомо за пределами схемы ответа.
+	raw, err := proto.Marshal(&stt.StreamingResponse{})
+	require.NoError(t, err)
+	require.Empty(t, raw)
+
+	return []byte{0xF8, 0xFF, 0x3F, 0x07}
+}

internal/adapter/recognizer/yandex/recognizer.go

@@ -9,6 +9,10 @@ import (
 	"git.vakhrushev.me/av/transcriber/internal/entity"
 )
 
+// ProviderName — имя провайдера, под которым сохраняется попытка распознавания.
+// По нему видно, чем считана запись, когда провайдеров станет больше одного.
+const ProviderName = "yandex-speechkit"
+
 type YandexAudioRecognizerConfig struct {
 	// s3
 	Region     string
@@ -56,36 +60,44 @@ func (s *YandexAudioRecognizerService) Close() error {
 	return s.sttService.Close()
 }
 
+func (s *YandexAudioRecognizerService) Provider() string { return ProviderName }
+
+func (s *YandexAudioRecognizerService) Model() string { return RecognitionModel }
+
 // startRecognitionTimeout — сколько ждём принятия операции, когда нас уже
 // остановили. Число меньше жёсткого предела остановки: иначе процесс убьют
 // прежде, чем ответ дойдёт, и защита ничего не даст.
 const startRecognitionTimeout = 10 * time.Second
 
-func (s *YandexAudioRecognizerService) Recognize(ctx context.Context, file io.Reader, fileName string) (string, error) {
-
-	// Заливка отменяется штатно: она дорога по времени, а повтор её бесплатен —
-	// объект ложится под тем же ключом.
-	err := s.s3Sevice.uploadFile(ctx, file, fileName)
-	if err != nil {
+// Upload кладёт аудио туда, откуда провайдер его прочитает.
+//
+// Отменяется штатно: заливка дорога по времени, а повтор её бесплатен — объект
+// ложится под тем же ключом.
+func (s *YandexAudioRecognizerService) Upload(ctx context.Context, file io.Reader, objectKey string) (string, error) {
+	if err := s.s3Sevice.uploadFile(ctx, file, objectKey); err != nil {
 		return "", err
 	}
+	return s.s3Sevice.fileUrl(objectKey), nil
+}
 
-	uri := s.s3Sevice.fileUrl(fileName)
+// ObjectExists отвечает, лежит ли объект нужного размера.
+//
+// Сверка идёт по присутствию и длине, а не по отпечатку содержимого: признак
+// целостности у составного объекта не равен отпечатку, и сверка хешем дала бы
+// расхождение на всякой большой записи.
+func (s *YandexAudioRecognizerService) ObjectExists(ctx context.Context, objectKey string, size int64) (bool, error) {
+	return s.s3Sevice.objectExists(ctx, objectKey, size)
+}
 
-	// А вот принятие операции от отмены защищено. Окно короткое и дорогое:
-	// SpeechKit может операцию принять и начать считать деньги, а ответ до нас
-	// не доедет — идентификатор потеряется навсегда, и повтор оплатит ту же
-	// запись второй раз. Свой предел вызову оставлен, чтобы остановка не ждала
-	// вечно.
+// Submit заводит операцию распознавания. Оплачивается наружу, поэтому от отмены
+// защищён: окно короткое и дорогое — SpeechKit может операцию принять и начать
+// считать деньги, а ответ до нас не доедет, и повтор оплатит ту же запись второй
+// раз. Свой предел вызову оставлен, чтобы остановка не ждала вечно.
+func (s *YandexAudioRecognizerService) Submit(ctx context.Context, sourceURI string) (string, error) {
 	startCtx, cancel := protectFromCancel(ctx, startRecognitionTimeout)
 	defer cancel()
 
-	opId, err := s.sttService.recognizeFileFromS3(startCtx, uri)
-	if err != nil {
-		return "", err
-	}
-
-	return opId, nil
+	return s.sttService.recognizeFileFromS3(startCtx, sourceURI)
 }
 
 // protectFromCancel отвязывает вызов от отмены родителя, оставляя ему значения
@@ -95,11 +107,26 @@ func protectFromCancel(ctx context.Context, timeout time.Duration) (context.Cont
 	return context.WithTimeout(context.WithoutCancel(ctx), timeout)
 }
 
-func (s *YandexAudioRecognizerService) GetRecognitionText(ctx context.Context, operationID string) (string, error) {
-	return s.sttService.getRecognitionText(ctx, operationID)
+// Fetch забирает готовый результат и отдаёт его доменным: реплики со временем,
+// плоский текст и байты ответа на хранение. Формата провайдера наружу не выходит
+// ничего — ни один шаг конвейера не знает, каким потоком тот отвечает.
+func (s *YandexAudioRecognizerService) Fetch(ctx context.Context, operationID string) (*entity.RecognitionOutcome, error) {
+	return s.sttService.fetchRecognition(ctx, operationID)
 }
 
-func (s *YandexAudioRecognizerService) CheckRecognitionStatus(ctx context.Context, operationID string) (*entity.RecognitionResult, error) {
+// Parse строит доменный результат из **сохранённого** ответа, не обращаясь к
+// провайдеру. По нему архив пересчитывается без единого рубля.
+func (s *YandexAudioRecognizerService) Parse(raw []byte) (*entity.RecognitionOutcome, error) {
+	responses, err := decodeResponses(raw)
+	if err != nil {
+		return nil, err
+	}
+	outcome := outcomeFromResponses(responses)
+	outcome.Raw = raw
+	return outcome, nil
+}
+
+func (s *YandexAudioRecognizerService) CheckStatus(ctx context.Context, operationID string) (*entity.RecognitionResult, error) {
 	operation, err := s.sttService.checkOperationStatus(ctx, operationID)
 	if err != nil {
 		return nil, err

internal/adapter/recognizer/yandex/s3.go

@@ -12,6 +12,7 @@ import (
 	"github.com/aws/aws-sdk-go-v2/credentials"
 	"github.com/aws/aws-sdk-go-v2/feature/s3/manager"
 	"github.com/aws/aws-sdk-go-v2/service/s3"
+	s3types "github.com/aws/aws-sdk-go-v2/service/s3/types"
 	"github.com/aws/smithy-go"
 )
 
@@ -89,6 +90,37 @@ func (s *yandexS3Service) uploadFile(ctx context.Context, file io.Reader, fileNa
 	return nil
 }
 
+// objectExists отвечает, лежит ли объект нужного размера.
+//
+// По нему шаг решает, повторять ли заливку: повтор её бесплатен, но дорог по
+// времени на многочасовой записи. Сверка идёт по присутствию и длине, а не по
+// отпечатку содержимого: признак целостности у составного объекта не равен
+// отпечатку, и сверка хешем расходилась бы на всякой большой записи.
+func (s *yandexS3Service) objectExists(ctx context.Context, objectKey string, size int64) (bool, error) {
+	out, err := s.client.HeadObject(ctx, &s3.HeadObjectInput{
+		Bucket: aws.String(s.bucketName),
+		Key:    aws.String(objectKey),
+	})
+	if err != nil {
+		var notFound *s3types.NotFound
+		if errors.As(err, &notFound) {
+			return false, nil
+		}
+		// Отказ SDK несёт полный URL объекта, а он — ключ к чужому аудио: наружу
+		// идёт класс отказа и только он.
+		var apiErr smithy.APIError
+		if errors.As(err, &apiErr) {
+			if apiErr.ErrorCode() == "NotFound" || apiErr.ErrorCode() == "NoSuchKey" {
+				return false, nil
+			}
+			return false, fmt.Errorf("failed to head object in S3: %s", apiErr.ErrorCode())
+		}
+		return false, errors.New("failed to head object in S3")
+	}
+
+	return out.ContentLength != nil && *out.ContentLength == size, nil
+}
+
 func (s *yandexS3Service) fileUrl(fileName string) string {
 	endpoint := strings.TrimRight(s.endpoint, "/")
 	return fmt.Sprintf("%s/%s/%s", endpoint, s.bucketName, fileName)

internal/adapter/recognizer/yandex/speechkit.go

@@ -2,17 +2,20 @@ package yandex
 
 import (
 	"context"
+	"encoding/binary"
 	"errors"
 	"fmt"
 	"io"
-	"strings"
 
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials"
 	"google.golang.org/grpc/metadata"
+	"google.golang.org/protobuf/proto"
 
 	stt "github.com/yandex-cloud/go-genproto/yandex/cloud/ai/stt/v3"
 	"github.com/yandex-cloud/go-genproto/yandex/cloud/operation"
+
+	"git.vakhrushev.me/av/transcriber/internal/entity"
 )
 
 const (
@@ -134,9 +137,13 @@ func (s *speechKitService) recognizeFileFromS3(ctx context.Context, s3URI string
 	return op.Id, nil
 }
 
-// GetRecognitionResult получает результат распознавания по ID операции
-func (s *speechKitService) getRecognitionText(ctx context.Context, operationID string) (string, error) {
-	// Добавляем авторизацию и folder_id в контекст
+// fetchRecognition забирает результат операции целиком и отдаёт его доменным,
+// вместе с сырым ответом на хранение.
+//
+// Ответ сохраняется потому, что **результат операции у провайдера не
+// переспрашивается**: связь реплики с говорящим сервис строить пока не умеет, и
+// когда научится, архив пересчитается из сохранённого без единого рубля.
+func (s *speechKitService) fetchRecognition(ctx context.Context, operationID string) (*entity.RecognitionOutcome, error) {
 	ctx = metadata.AppendToOutgoingContext(ctx, "authorization", "Api-Key "+s.apiKey)
 	ctx = metadata.AppendToOutgoingContext(ctx, "x-folder-id", s.folderID)
 
@@ -146,11 +153,10 @@ func (s *speechKitService) getRecognitionText(ctx context.Context, operationID s
 
 	stream, err := s.sttClient.GetRecognition(ctx, req)
 	if err != nil {
-		return "", fmt.Errorf("failed to get recognition stream: %w", err)
+		return nil, fmt.Errorf("failed to get recognition stream: %w", err)
 	}
 
-	var sb strings.Builder
-
+	var responses []*stt.StreamingResponse
 	for {
 		resp, err := stream.Recv()
 		if err != nil {
@@ -160,19 +166,19 @@ func (s *speechKitService) getRecognitionText(ctx context.Context, operationID s
 			if errors.Is(err, io.EOF) {
 				break
 			}
-			return "", fmt.Errorf("failed to receive recognition response: %w", err)
-		}
-		if refinement := resp.GetFinalRefinement(); refinement != nil {
-			if text := refinement.GetNormalizedText(); text != nil {
-				for _, alt := range text.Alternatives {
-					sb.WriteString(alt.Text)
-					sb.WriteString(" ")
-				}
-			}
+			return nil, fmt.Errorf("failed to receive recognition response: %w", err)
 		}
+		responses = append(responses, resp)
 	}
 
-	return sb.String(), nil
+	raw, err := encodeResponses(responses)
+	if err != nil {
+		return nil, err
+	}
+
+	outcome := outcomeFromResponses(responses)
+	outcome.Raw = raw
+	return outcome, nil
 }
 
 // checkOperationStatus проверяет статус операции распознавания
@@ -190,3 +196,92 @@ func (s *speechKitService) checkOperationStatus(ctx context.Context, operationID
 
 	return op, nil
 }
+
+// encodeResponses укладывает ответ провайдера целиком, в том виде, в каком он
+// пришёл: сообщения потока подряд, каждое со своей длиной впереди.
+//
+// Форма **двоичная**, а не текстовая, и это несущее решение. Текстовое
+// представление собирается по нашей скомпилированной схеме и молча выбрасывает
+// поля, которых в ней нет, — а провайдер добавляет их без предупреждения.
+// Двоичная форма неизвестные поля переносит: они переживают запись и чтение и
+// станут читаемыми, когда мы обновим схему. Ради этого архив и заводился —
+// результат операции у провайдера не переспрашивается, и повторное
+// распознавание стоит денег.
+//
+// Цена названа прямо: сохранённое не читается глазами и не разбирается ничем,
+// кроме нашего же кода.
+func encodeResponses(responses []*stt.StreamingResponse) ([]byte, error) {
+	var raw []byte
+	for _, resp := range responses {
+		encoded, err := proto.Marshal(resp)
+		if err != nil {
+			// Текст расшифровки наружу не выходит даже отказом: сообщение
+			// провайдера несёт её целиком.
+			return nil, errors.New("failed to encode provider response")
+		}
+		raw = binary.AppendUvarint(raw, uint64(len(encoded)))
+		raw = append(raw, encoded...)
+	}
+	return raw, nil
+}
+
+// decodeResponses читает сохранённый ответ провайдера обратно.
+func decodeResponses(raw []byte) ([]*stt.StreamingResponse, error) {
+	var responses []*stt.StreamingResponse
+
+	for len(raw) > 0 {
+		size, read := binary.Uvarint(raw)
+		if read <= 0 || uint64(len(raw)-read) < size {
+			return nil, errors.New("stored provider payload is truncated")
+		}
+		raw = raw[read:]
+
+		var resp stt.StreamingResponse
+		if err := proto.Unmarshal(raw[:size], &resp); err != nil {
+			return nil, errors.New("failed to decode provider response")
+		}
+		responses = append(responses, &resp)
+		raw = raw[size:]
+	}
+
+	return responses, nil
+}
+
+// outcomeFromResponses строит доменный результат: реплики со временем и плоский
+// текст. Формата провайдера отсюда наружу не выходит ничего.
+//
+// Говорящие не размечаются: связь реплики с разбором говорящего у провайдера не
+// выяснена. Структура при этом строится из сохранённого ответа, поэтому разметка
+// станет возможной без повторной оплаты.
+func outcomeFromResponses(responses []*stt.StreamingResponse) *entity.RecognitionOutcome {
+	outcome := &entity.RecognitionOutcome{}
+
+	var plain []byte
+	for _, resp := range responses {
+		refinement := resp.GetFinalRefinement()
+		if refinement == nil {
+			continue
+		}
+		text := refinement.GetNormalizedText()
+		if text == nil {
+			continue
+		}
+		for _, alt := range text.GetAlternatives() {
+			if alt.GetText() == "" {
+				continue
+			}
+			outcome.Replicas = append(outcome.Replicas, entity.Replica{
+				StartMs: alt.GetStartTimeMs(),
+				EndMs:   alt.GetEndTimeMs(),
+				Text:    alt.GetText(),
+			})
+			if len(plain) > 0 {
+				plain = append(plain, ' ')
+			}
+			plain = append(plain, alt.GetText()...)
+		}
+	}
+
+	outcome.PlainText = string(plain)
+	return outcome
+}

internal/adapter/repo/pocketbase/file_repo.go

@@ -112,11 +112,15 @@ func (repo *FileRepository) Localize(fileID string) (contract.WorkFile, error) {
 	return work, nil
 }
 
-// CreateLocal кладёт рабочую копию в хранилище. Имя задаём мы: умолчание
-// библиотеки строит его из имени, данного отправителем, а имя отправителя в
-// хранилище не попадает — путь к файлу читается в журнале, и инвариант
-// приватности этого не допускает. Свой суффикс хранилище допишет само.
-func (repo *FileRepository) CreateLocal(name string, work contract.WorkFile, ownerID string) (*entity.File, error) {
+// Create кладёт рабочую копию в хранилище. Имя задаём мы: умолчание библиотеки
+// строит его из имени, данного отправителем, а имя отправителя в хранилище не
+// попадает — путь к файлу читается в журнале, и инвариант приватности этого не
+// допускает. Свой суффикс хранилище допишет само.
+//
+// Копий у записи ровно две — принятая и приведённая, — и обе местные. Прежний
+// путь заведения записи о копии во внешнем хранилище отсюда ушёл: та копия
+// файлом записи не считается, а её ключ живёт в строке попытки распознавания.
+func (repo *FileRepository) Create(name string, work contract.WorkFile, meta contract.FileMeta, ownerID string) (*entity.File, error) {
 	collection, err := findCollection(repo.app, migrations.FilesCollection)
 	if err != nil {
 		return nil, err
@@ -132,6 +136,8 @@ func (repo *FileRepository) CreateLocal(name string, work contract.WorkFile, own
 	record.Set("file", stored)
 	record.Set("location", entity.LocationLocal)
 	record.Set("size", stored.Size)
+	record.Set("format", meta.Format)
+	record.Set("duration_ms", meta.DurationMs)
 	// Владелец файла — владелец записи, которой файл принадлежит. Пустой значит
 	// «файл без владельца»: таков всякий файл записи, принятой ботом. Правило
 	// просмотра коллекции сужено этой колонкой, и без неё чужое аудио осталось
@@ -148,25 +154,6 @@ func (repo *FileRepository) CreateLocal(name string, work contract.WorkFile, own
 	return recordToFile(record), nil
 }
 
-func (repo *FileRepository) CreateRemote(objectKey string, size int64, ownerID string) (*entity.File, error) {
-	collection, err := findCollection(repo.app, migrations.FilesCollection)
-	if err != nil {
-		return nil, err
-	}
-
-	record := core.NewRecord(collection)
-	record.Set("location", entity.LocationS3)
-	record.Set("object_key", objectKey)
-	record.Set("size", size)
-	record.Set("owner", ownerID)
-
-	if err := repo.app.Save(record); err != nil {
-		return nil, fmt.Errorf("failed to store remote file record: %w", err)
-	}
-
-	return recordToFile(record), nil
-}
-
 func (repo *FileRepository) GetByID(id string) (*entity.File, error) {
 	record, err := repo.app.FindRecordById(migrations.FilesCollection, id)
 	if err != nil {
@@ -262,16 +249,13 @@ func firstFileName(record *core.Record) string {
 }
 
 func recordToFile(record *core.Record) *entity.File {
-	name := firstFileName(record)
-	if name == "" {
-		name = record.GetString("object_key")
-	}
-
 	return &entity.File{
-		Id:        record.Id,
-		Location:  record.GetString("location"),
-		FileName:  name,
-		Size:      int64(record.GetInt("size")),
-		CreatedAt: record.GetDateTime("created").Time(),
+		Id:         record.Id,
+		Location:   record.GetString("location"),
+		FileName:   firstFileName(record),
+		Size:       int64(record.GetInt("size")),
+		Format:     record.GetString("format"),
+		DurationMs: int64(record.GetInt("duration_ms")),
+		CreatedAt:  record.GetDateTime("created").Time(),
 	}
 }

internal/adapter/repo/pocketbase/file_repo_test.go

@@ -1,38 +0,0 @@
-package pocketbase
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"git.vakhrushev.me/av/transcriber/internal/entity"
-)
-
-// Потолок размера у поля файла задан числом, а не нулём: нулём библиотека читает
-// собственное умолчание в 5 МиБ, и на нём отвергалось бы всё длиннее примерно
-// пяти минут — то есть штатная запись сервиса. Проверка судит запись, которая
-// заведомо больше этого умолчания: обновление библиотеки, вернувшее умолчание,
-// иначе прошло бы молча.
-func TestCreateLocal_AcceptsRecordLargerThanLibraryDefault(t *testing.T) {
-	app := newTestApp(t)
-	repo := NewFileRepository(app)
-
-	const libraryDefault = 5 << 20
-
-	// Ровно на байт больше умолчания: проверка судит границу, а не пропускную
-	// способность — лишние мегабайты стоили бы секунд на каждом прогоне.
-	work, err := repo.Stage(".mp3", strings.NewReader(strings.Repeat("a", libraryDefault+1)))
-	require.NoError(t, err)
-	defer func() { require.NoError(t, work.Close()) }()
-
-	size, err := work.Size()
-	require.NoError(t, err)
-	require.Greater(t, size, int64(libraryDefault), "запись заведомо больше умолчания библиотеки")
-
-	file, err := repo.CreateLocal("big.mp3", work, "")
-	require.NoError(t, err, "запись длиннее умолчания библиотеки ложится в хранилище")
-	assert.Equal(t, size, file.Size)
-	assert.Greater(t, entity.MaxRecordSize, size, "объявленный потолок выше проверяемого размера")
-}

internal/adapter/repo/pocketbase/job_mapping.go

@@ -1,214 +0,0 @@
-package pocketbase
-
-import (
-	"database/sql"
-	"time"
-
-	"github.com/pocketbase/pocketbase/core"
-	"github.com/pocketbase/pocketbase/tools/types"
-
-	"git.vakhrushev.me/av/transcriber/internal/entity"
-)
-
-// Отображение задачи в запись коллекции и обратно живёт одним местом. Прежде
-// список колонок был переписан четырежды — в каждом запросе своего слоя, — и
-// расхождение проявлялось как потерянное при сохранении поле.
-
-// applyOwnedByPipeline кладёт в запись только те поля, которыми распоряжается
-// конвейер. Поля, которые он не меняет никогда — куда отвечать отправителю и
-// каким входом пришла запись, — не трогаются вовсе.
-//
-// Разрез нужен потому, что шаг держит задачу снимком с момента захвата и до
-// своего сохранения, а это до восьми часов. Всё, что владелец правил в панели за
-// это время, безусловная запись снимка стёрла бы молча: ни строки в журнале, ни
-// отказа в панели — владелец видел бы успешное сохранение и был бы уверен, что
-// правка на месте.
-func applyOwnedByPipeline(record *core.Record, job *entity.TranscribeJob) {
-	record.Set("state", job.State)
-	record.Set("file", derefString(job.FileID))
-	record.Set("error_text", derefString(job.ErrorText))
-	record.Set("acquisition_id", derefString(job.AcquisitionID))
-	record.Set("acquire_time", dateOrEmpty(job.AcquireTime))
-	record.Set("delay_time", dateOrEmpty(job.DelayTime))
-	record.Set("attempts", job.Attempts)
-	record.Set("recognition_op_id", derefString(job.RecognitionOpID))
-	record.Set("transcription_text", derefString(job.TranscriptionText))
-}
-
-// applyToRecord кладёт задачу в запись целиком — это заведение, и спорить за
-// поля здесь не с кем.
-func applyToRecord(record *core.Record, job *entity.TranscribeJob) {
-	applyOwnedByPipeline(record, job)
-	// Владелец кладётся только здесь, при заведении. В applyOwnedByPipeline его
-	// нет намеренно: конвейер владельца не назначает и не меняет, а снимок шага,
-	// записанный поверх, стёр бы его молча.
-	record.Set("owner", derefString(job.OwnerID))
-	record.Set("source", job.Source)
-	record.Set("tg_chat_id", derefInt64(job.TgChatId))
-	record.Set("tg_reply_message_id", derefInt(job.TgReplyMessageId))
-}
-
-func recordToJob(record *core.Record) *entity.TranscribeJob {
-	return &entity.TranscribeJob{
-		Id:                record.Id,
-		State:             record.GetString("state"),
-		OwnerID:           nilIfEmpty(record.GetString("owner")),
-		Source:            record.GetString("source"),
-		FileID:            nilIfEmpty(record.GetString("file")),
-		ErrorText:         nilIfEmpty(record.GetString("error_text")),
-		AcquisitionID:     nilIfEmpty(record.GetString("acquisition_id")),
-		AcquireTime:       timeOrNil(record.GetDateTime("acquire_time")),
-		DelayTime:         timeOrNil(record.GetDateTime("delay_time")),
-		Attempts:          record.GetInt("attempts"),
-		RecognitionOpID:   nilIfEmpty(record.GetString("recognition_op_id")),
-		TranscriptionText: nilIfEmpty(record.GetString("transcription_text")),
-		TgChatId:          nilIfZero64(int64(record.GetInt("tg_chat_id"))),
-		TgReplyMessageId:  nilIfZeroInt(record.GetInt("tg_reply_message_id")),
-		CreatedAt:         record.GetDateTime("created").Time(),
-		UpdatedAt:         record.GetDateTime("updated").Time(),
-	}
-}
-
-// acquiredRow — задача, прочитанная сырым запросом захвата. Колонки читаются
-// именно так, потому что запрос идёт мимо записей коллекции; связь с их
-// перечнем держит константа acquireColumns и тест захвата, читающий задачу
-// целиком.
-type acquiredRow struct {
-	Id    string `db:"id"`
-	State string `db:"state"`
-	// Владелец конвейеру не нужен для выборки — она им не сужается, — но
-	// читается: снимок задачи, в котором владелец всегда пуст, был бы ловушкой
-	// для первого же шага, начавшего сохранять задачу целиком. Сегодня это ещё
-	// и несущее чтение: шаг конвейера кладёт владельца на файл, который заводит.
-	OwnerID           sql.NullString `db:"owner"`
-	Source            string         `db:"source"`
-	FileID            sql.NullString `db:"file"`
-	ErrorText         sql.NullString `db:"error_text"`
-	AcquisitionID     sql.NullString `db:"acquisition_id"`
-	AcquireTime       sql.NullString `db:"acquire_time"`
-	DelayTime         sql.NullString `db:"delay_time"`
-	Attempts          int            `db:"attempts"`
-	RecognitionOpID   sql.NullString `db:"recognition_op_id"`
-	TranscriptionText sql.NullString `db:"transcription_text"`
-	TgChatId          sql.NullInt64  `db:"tg_chat_id"`
-	TgReplyMessageId  sql.NullInt64  `db:"tg_reply_message_id"`
-	Created           sql.NullString `db:"created"`
-	Updated           sql.NullString `db:"updated"`
-}
-
-func (r *acquiredRow) toJob() *entity.TranscribeJob {
-	job := &entity.TranscribeJob{
-		Id:                r.Id,
-		State:             r.State,
-		OwnerID:           nullToPtr(r.OwnerID),
-		Source:            r.Source,
-		FileID:            nullToPtr(r.FileID),
-		ErrorText:         nullToPtr(r.ErrorText),
-		AcquisitionID:     nullToPtr(r.AcquisitionID),
-		AcquireTime:       parseTimeOrNil(r.AcquireTime),
-		DelayTime:         parseTimeOrNil(r.DelayTime),
-		Attempts:          r.Attempts,
-		RecognitionOpID:   nullToPtr(r.RecognitionOpID),
-		TranscriptionText: nullToPtr(r.TranscriptionText),
-	}
-
-	if r.TgChatId.Valid && r.TgChatId.Int64 != 0 {
-		chatId := r.TgChatId.Int64
-		job.TgChatId = &chatId
-	}
-	if r.TgReplyMessageId.Valid && r.TgReplyMessageId.Int64 != 0 {
-		msgId := int(r.TgReplyMessageId.Int64)
-		job.TgReplyMessageId = &msgId
-	}
-	if created := parseTimeOrNil(r.Created); created != nil {
-		job.CreatedAt = *created
-	}
-	if updated := parseTimeOrNil(r.Updated); updated != nil {
-		job.UpdatedAt = *updated
-	}
-
-	return job
-}
-
-func derefString(v *string) string {
-	if v == nil {
-		return ""
-	}
-	return *v
-}
-
-func derefInt64(v *int64) int64 {
-	if v == nil {
-		return 0
-	}
-	return *v
-}
-
-func derefInt(v *int) int {
-	if v == nil {
-		return 0
-	}
-	return *v
-}
-
-// dateOrEmpty отдаёт пустое значение вместо нулевой даты: пустая колонка даты в
-// хранилище это пустая строка, и она же значит «времени нет».
-func dateOrEmpty(v *time.Time) any {
-	if v == nil {
-		return ""
-	}
-	date, err := types.ParseDateTime(*v)
-	if err != nil {
-		return ""
-	}
-	return date
-}
-
-func nilIfEmpty(v string) *string {
-	if v == "" {
-		return nil
-	}
-	return &v
-}
-
-func timeOrNil(v types.DateTime) *time.Time {
-	if v.IsZero() {
-		return nil
-	}
-	t := v.Time()
-	return &t
-}
-
-func nilIfZero64(v int64) *int64 {
-	if v == 0 {
-		return nil
-	}
-	return &v
-}
-
-func nilIfZeroInt(v int) *int {
-	if v == 0 {
-		return nil
-	}
-	return &v
-}
-
-func nullToPtr(v sql.NullString) *string {
-	if !v.Valid || v.String == "" {
-		return nil
-	}
-	s := v.String
-	return &s
-}
-
-func parseTimeOrNil(v sql.NullString) *time.Time {
-	if !v.Valid || v.String == "" {
-		return nil
-	}
-	date, err := types.ParseDateTime(v.String)
-	if err != nil || date.IsZero() {
-		return nil
-	}
-	t := date.Time()
-	return &t
-}

internal/adapter/repo/pocketbase/migrations/202608140002_record_centric_model.go

@@ -0,0 +1,347 @@
+package migrations
+
+import (
+	"fmt"
+
+	"github.com/pocketbase/pocketbase/core"
+
+	"git.vakhrushev.me/av/transcriber/internal/entity"
+)
+
+// up202608140002 перестраивает модель вокруг аудиозаписи.
+//
+// Прежняя коллекция задач уходит целиком: сервис на сервере остановлен, а
+// прежние данные удалены решением владельца 2026-08-14 — переноса эта работа не
+// делает, и оставленная пустая коллекция висела бы в панели вторым домом для
+// того же понятия.
+//
+// Порядок заведения задан связями, а не вкусом: приложения ссылаются на запись,
+// а запись — на них, поэтому запись заводится первой без обратных ссылок, потом
+// приложения, и только потом ссылки дописываются.
+//
+// Правила доступа у новых коллекций остаются **незаданными**, то есть «только
+// владелец панели». Содержимое записи отдаёт собственный адрес сервиса, а не
+// поверхность хранилища; непустое правило открыло бы перечисление коллекции
+// впрок, а норма проекта велит держать эту поверхность закрытой.
+func up202608140002(app core.App) error {
+	users, err := app.FindCollectionByNameOrId(UsersCollection)
+	if err != nil {
+		return fmt.Errorf("failed to find users collection: %w", err)
+	}
+
+	files, err := app.FindCollectionByNameOrId(FilesCollection)
+	if err != nil {
+		return fmt.Errorf("failed to find files collection: %w", err)
+	}
+
+	// Формат и длительность у копии: по ним видно, чем запись была, не открывая
+	// её. Расширение наружу выходит только приведённым к перечню известных.
+	files.Fields.Add(
+		&core.TextField{Name: "format"},
+		&core.NumberField{Name: "duration_ms", OnlyInt: true},
+	)
+	if err := app.Save(files); err != nil {
+		return fmt.Errorf("failed to extend files: %w", err)
+	}
+
+	topics, err := createTopics(app, users.Id)
+	if err != nil {
+		return err
+	}
+
+	records, err := createAudioRecords(app, users.Id, files.Id, topics.Id)
+	if err != nil {
+		return err
+	}
+
+	texts, err := createTexts(app, records.Id)
+	if err != nil {
+		return err
+	}
+
+	structures, err := createStructures(app, records.Id)
+	if err != nil {
+		return err
+	}
+
+	recognitions, err := createRecognitions(app, records.Id)
+	if err != nil {
+		return err
+	}
+
+	if err := createRecordEvents(app, records.Id); err != nil {
+		return err
+	}
+
+	// Обратные ссылки дописываются последними: раньше коллекций-целей ещё нет.
+	records.Fields.Add(
+		&core.RelationField{Name: "transcript_text", CollectionId: texts.Id, MaxSelect: 1},
+		&core.RelationField{Name: "literary_text", CollectionId: texts.Id, MaxSelect: 1},
+		&core.RelationField{Name: "structure", CollectionId: structures.Id, MaxSelect: 1},
+		&core.RelationField{Name: "recognition", CollectionId: recognitions.Id, MaxSelect: 1},
+	)
+	if err := app.Save(records); err != nil {
+		return fmt.Errorf("failed to link audio records to their appendices: %w", err)
+	}
+
+	jobs, err := app.FindCollectionByNameOrId(JobsCollection)
+	if err != nil {
+		return fmt.Errorf("failed to find jobs collection: %w", err)
+	}
+	if err := app.Delete(jobs); err != nil {
+		return fmt.Errorf("failed to drop the former jobs collection: %w", err)
+	}
+
+	return nil
+}
+
+// createAudioRecords заводит центральную сущность.
+//
+// Ссылки на файлы две и порознь: шаг конвейера больше не переставляет одну на
+// свой результат, и исходник остаётся доступным после того, как запись прошла
+// конвейер.
+func createAudioRecords(app core.App, usersID, filesID, topicsID string) (*core.Collection, error) {
+	records := core.NewBaseCollection(RecordsCollection)
+	records.Fields.Add(
+		ownerField(usersID),
+		&core.SelectField{
+			Name:      "source",
+			Values:    []string{entity.SourceUnknown, entity.SourceApi, entity.SourceTelegram},
+			MaxSelect: 1,
+			Required:  true,
+		},
+		// Заголовок и краткое описание читаются вместе со списком, сотней штук
+		// разом, и потому лежат колонками записи, а не строками текстов.
+		&core.TextField{Name: "title"},
+		&core.TextField{Name: "brief"},
+		// Перечень рубежей закрыт схемой: запись, заведённая в панели руками, не
+		// должна попасть в выборку с рубежом, которого конвейер не знает.
+		&core.SelectField{
+			Name:      "state",
+			Values:    entity.AllStates(),
+			MaxSelect: 1,
+			Required:  true,
+		},
+		// Время входа в рубеж — сторож застревания. Ставится только сменой рубежа
+		// и возвратом записи в работу; откладывание опроса его не двигает.
+		&core.DateField{Name: "state_entered_at"},
+		// Остановка — признак, а не рубеж: `state` при ней не стирается, и снятие
+		// признака продолжает работу с места остановки.
+		&core.DateField{Name: "halted_at"},
+		&core.SelectField{
+			Name:      "halt_reason",
+			Values:    entity.AllHaltReasons(),
+			MaxSelect: 1,
+		},
+		&core.TextField{Name: "error_text"},
+		// Признак **этого** захвата: значение уникально для каждого захвата, и
+		// запись результата условна по нему, а не по занятости записи.
+		&core.TextField{Name: "acquisition_id"},
+		// Срок протухания захвата приезжает с рубежом и пишется числом при самом
+		// захвате: воркер не привязан к шагу и вывести срок из себя не может.
+		&core.DateField{Name: "acquire_expires_at"},
+		&core.DateField{Name: "delay_time"},
+		// Число отказов ограничивает повторы внутри шага. Время в рубеже мерит
+		// отдельный сторож: одно число не справлялось ни с одной из обязанностей.
+		&core.NumberField{Name: "attempts", OnlyInt: true, Min: ptr(0.0)},
+		&core.RelationField{Name: "original_file", CollectionId: filesID, MaxSelect: 1},
+		&core.RelationField{Name: "normalized_file", CollectionId: filesID, MaxSelect: 1},
+		&core.RelationField{
+			Name:         "topics",
+			CollectionId: topicsID,
+			MaxSelect:    entity.MaxTopicsPerRecord,
+		},
+		&core.NumberField{Name: "tg_chat_id", OnlyInt: true},
+		&core.NumberField{Name: "tg_reply_message_id", OnlyInt: true},
+		&core.AutodateField{Name: "created", OnCreate: true},
+		&core.AutodateField{Name: "updated", OnCreate: true, OnUpdate: true},
+	)
+
+	// Отбор захвата идёт по рубежу, признаку остановки, паузе и сроку протухания
+	// захвата — индекс снимает полный перебор.
+	records.AddIndex("idx_audio_records_state", false, "state, halted_at", "")
+
+	if err := app.Save(records); err != nil {
+		return nil, fmt.Errorf("failed to create audio records: %w", err)
+	}
+	return records, nil
+}
+
+// createTexts заводит тексты записи. Пара «запись и вид» уникальна: повтор
+// прерванного шага иначе завёл бы второй комплект строк, и вопрос «какой текст
+// отдавать человеку» стал бы вопросом порядка записи, а не состояния.
+func createTexts(app core.App, recordsID string) (*core.Collection, error) {
+	texts := core.NewBaseCollection(TextsCollection)
+	texts.Fields.Add(
+		&core.RelationField{Name: "record", CollectionId: recordsID, MaxSelect: 1, Required: true},
+		&core.SelectField{
+			Name:      "kind",
+			Values:    entity.AllTextKinds(),
+			MaxSelect: 1,
+			Required:  true,
+		},
+		// Поле зовётся `kind`, а не `format`: словом `format` в этой же схеме
+		// зовут формат файла, и третий смысл у одного слова развёл бы по разным
+		// вещам вид текста и формат копии.
+		&core.EditorField{Name: "contents"},
+		&core.AutodateField{Name: "created", OnCreate: true},
+		&core.AutodateField{Name: "updated", OnCreate: true, OnUpdate: true},
+	)
+	texts.AddIndex("idx_texts_record_kind", true, "record, kind", "")
+
+	if err := app.Save(texts); err != nil {
+		return nil, fmt.Errorf("failed to create texts: %w", err)
+	}
+	return texts, nil
+}
+
+// createStructures заводит структуру реплик. Номер версии нужен потому, что
+// разбор сохранённого ответа изменится раньше, чем архив пересчитают.
+func createStructures(app core.App, recordsID string) (*core.Collection, error) {
+	structures := core.NewBaseCollection(StructuresCollection)
+	structures.Fields.Add(
+		&core.RelationField{Name: "record", CollectionId: recordsID, MaxSelect: 1, Required: true},
+		&core.NumberField{Name: "version", OnlyInt: true, Required: true},
+		&core.JSONField{Name: "contents", MaxSize: structureContentsMaxSize},
+		&core.AutodateField{Name: "created", OnCreate: true},
+		&core.AutodateField{Name: "updated", OnCreate: true, OnUpdate: true},
+	)
+	structures.AddIndex("idx_structures_record_version", true, "record, version", "")
+
+	if err := app.Save(structures); err != nil {
+		return nil, fmt.Errorf("failed to create structures: %w", err)
+	}
+	return structures, nil
+}
+
+// createRecognitions заводит попытку распознавания у внешнего провайдера.
+//
+// Сырой ответ лежит **вложением**, а не колонкой: шаг опроса читает эту строку
+// раз в несколько секунд, а хранилище читает запись целиком — ответ на
+// многочасовую запись ехал бы в память при каждом опросе.
+//
+// Поле вложения помечено защищённым: сырой ответ это полный текст речи, и
+// умолчание библиотеки отдавало бы его по ссылке любому, кто её знает.
+func createRecognitions(app core.App, recordsID string) (*core.Collection, error) {
+	recognitions := core.NewBaseCollection(RecognitionsCollection)
+	payload := &core.FileField{Name: "payload", MaxSelect: 1, MaxSize: recognitionPayloadMaxSize}
+	payload.Protected = true
+
+	recognitions.Fields.Add(
+		&core.RelationField{Name: "record", CollectionId: recordsID, MaxSelect: 1, Required: true},
+		&core.TextField{Name: "provider", Required: true},
+		&core.TextField{Name: "model"},
+		// Идентификатор операции у провайдера — самое провайдерское, что есть в
+		// модели, и живёт он здесь, а не колонкой записи.
+		&core.TextField{Name: "external_id"},
+		// Адрес, по которому провайдер читает аудио. Копия во внешнем хранилище
+		// файлом записи не считается: другой провайдер её не потребует.
+		&core.TextField{Name: "source_uri"},
+		payload,
+		&core.DateField{Name: "started_at"},
+		&core.DateField{Name: "finished_at"},
+		&core.AutodateField{Name: "created", OnCreate: true},
+		&core.AutodateField{Name: "updated", OnCreate: true, OnUpdate: true},
+	)
+
+	if err := app.Save(recognitions); err != nil {
+		return nil, fmt.Errorf("failed to create recognitions: %w", err)
+	}
+	return recognitions, nil
+}
+
+// createRecordEvents заводит журнал событий записи.
+//
+// Колонка текста отказа зовётся `outcome_text`, а не `error_text`: последнее имя
+// названо поимённо инвариантом проекта о секрете, и две колонки с этим именем
+// сделали бы инвариант двусмысленным.
+func createRecordEvents(app core.App, recordsID string) error {
+	events := core.NewBaseCollection(RecordEventsCollection)
+	events.Fields.Add(
+		&core.RelationField{Name: "record", CollectionId: recordsID, MaxSelect: 1, Required: true},
+		&core.SelectField{
+			Name:      "origin",
+			Values:    entity.AllEventOrigins(),
+			MaxSelect: 1,
+			Required:  true,
+		},
+		&core.TextField{Name: "step"},
+		&core.SelectField{
+			Name:      "outcome",
+			Values:    entity.AllEventOutcomes(),
+			MaxSelect: 1,
+			Required:  true,
+		},
+		&core.TextField{Name: "outcome_text"},
+		&core.NumberField{Name: "duration_ms", OnlyInt: true},
+		&core.AutodateField{Name: "created", OnCreate: true},
+	)
+	events.AddIndex("idx_record_events_record", false, "record", "")
+
+	if err := app.Save(events); err != nil {
+		return fmt.Errorf("failed to create record events: %w", err)
+	}
+	return nil
+}
+
+// createTopics заводит словарь тем. Тема уникальна в паре «владелец и название»:
+// словарь свой у каждого человека, и общий показал бы одному темы другого.
+func createTopics(app core.App, usersID string) (*core.Collection, error) {
+	topics := core.NewBaseCollection(TopicsCollection)
+	topics.Fields.Add(
+		&core.RelationField{
+			Name:         "owner",
+			CollectionId: usersID,
+			MaxSelect:    1,
+			Required:     true,
+		},
+		&core.TextField{Name: "name", Required: true},
+		&core.AutodateField{Name: "created", OnCreate: true},
+		&core.AutodateField{Name: "updated", OnCreate: true, OnUpdate: true},
+	)
+	topics.AddIndex("idx_topics_owner_name", true, "owner, name", "")
+
+	if err := app.Save(topics); err != nil {
+		return nil, fmt.Errorf("failed to create topics: %w", err)
+	}
+	return topics, nil
+}
+
+const (
+	// structureContentsMaxSize — потолок разбитой на реплики расшифровки. Число
+	// с запасом: шестичасовой разговор даёт порядка мегабайта текста с временем.
+	structureContentsMaxSize = 16 << 20
+	// recognitionPayloadMaxSize — потолок сохранённого ответа провайдера. Он
+	// многословнее самой расшифровки: несёт альтернативы, время каждого слова и
+	// разбор говорящих.
+	recognitionPayloadMaxSize = 256 << 20
+)
+
+// Поля объявляются россыпью, а не помощником, который принимал бы имя доводом:
+// сверка перечня колонок со схемой читает литерал `Name:` в шагах, и имя,
+// спрятанное за вызовом, она не видит — колонка выпала бы из-под правила молча.
+
+// down202608140002 снимает новые коллекции. Прежнюю коллекцию задач он не
+// восстанавливает: данных под ней не было, а пустая копия прежней схемы была бы
+// вторым домом для понятия, которого больше нет.
+func down202608140002(app core.App) error {
+	// Порядок обратный порядку заведения: приложения ссылаются на запись.
+	order := []string{
+		RecordEventsCollection,
+		RecognitionsCollection,
+		StructuresCollection,
+		TextsCollection,
+		RecordsCollection,
+		TopicsCollection,
+	}
+	for _, name := range order {
+		collection, err := app.FindCollectionByNameOrId(name)
+		if err != nil {
+			continue
+		}
+		if err := app.Delete(collection); err != nil {
+			return fmt.Errorf("failed to drop %s: %w", name, err)
+		}
+	}
+	return nil
+}

internal/adapter/repo/pocketbase/migrations/migrations.go

@@ -23,7 +23,19 @@ import (
 // меняются только новым шагом схемы.
 const (
 	FilesCollection = "files"
-	JobsCollection  = "transcribe_jobs"
+	// JobsCollection — прежняя коллекция задач. Шаг 202608140002 её удаляет;
+	// имя остаётся здесь, потому что на него ссылаются прежние шаги схемы, а
+	// применённый шаг не переписывается.
+	JobsCollection = "transcribe_jobs"
+	// RecordsCollection — аудиозапись, центральная сущность сервиса. Имя в
+	// snake_case, как у соседей по схеме: одно исключение разошлось бы молча по
+	// константе имён, запросу захвата, правилам панели и запрету удаления.
+	RecordsCollection      = "audio_records"
+	TextsCollection        = "texts"
+	StructuresCollection   = "structures"
+	RecognitionsCollection = "recognitions"
+	RecordEventsCollection = "record_events"
+	TopicsCollection       = "topics"
 	// UsersCollection заводит не наш шаг, а системный шаг библиотеки. Имя стоит
 	// здесь потому, что на него ссылаются и шаги схемы, и проверка предъявителя
 	// на приёме: строковый литерал в двух местах разошёлся бы молча.
@@ -36,6 +48,7 @@ func init() {
 	pbmigrations.Register(up202608110001, down202608110001, "202608110001_init.go")
 	pbmigrations.Register(up202608120001, down202608120001, "202608120001_oidc_login.go")
 	pbmigrations.Register(up202608140001, down202608140001, "202608140001_record_owner.go")
+	pbmigrations.Register(up202608140002, down202608140002, "202608140002_record_centric_model.go")
 }
 
 func ptr[T any](v T) *T { return &v }

internal/adapter/repo/pocketbase/owner_guard.go

@@ -11,7 +11,7 @@ import (
 )
 
 // GuardOwnerDeletion отвергает удаление учётной записи, у которой остались
-// задачи расшифровки.
+// аудиозаписи, их файлы либо темы её словаря.
 //
 // Колонка владельца — связь с выключенным каскадным удалением, и одного этого
 // мало: при выключенном каскаде хранилище не удаляет ссылающуюся запись, а
@@ -29,10 +29,11 @@ import (
 // только панельное — умолчание библиотеки разрешает вошедшему удалить свою
 // учётную запись запросом, так что страж закрывает и публичную поверхность.
 //
-// Считаются **обе** коллекции с владельцем. Файл переживает свою задачу: шаг
-// конвейера заводит его до сохранения задачи, и потерянный захват оставляет файл
-// с владельцем и без ссылки. Учётная запись, у которой остались одни такие
-// файлы, без этого счёта удалялась бы штатно, а аудио становилось бы ничьим.
+// Считаются **все** коллекции с владельцем, и перечень их живёт одним списком
+// ниже. Файл переживает свою запись: шаг конвейера заводит его до сохранения, и
+// потерянный захват оставляет файл с владельцем и без ссылки. Учётная запись, у
+// которой остались одни такие файлы, без этого счёта удалялась бы штатно, а
+// аудио становилось бы ничьим.
 func GuardOwnerDeletion(app core.App) {
 	app.OnRecordDelete(migrations.UsersCollection).BindFunc(func(e *core.RecordEvent) error {
 		count, err := countOwned(e.App, e.Record.Id)
@@ -62,13 +63,25 @@ func GuardOwnerDeletion(app core.App) {
 	})
 }
 
-// countOwned считает всё, что принадлежит учётной записи, — по обеим коллекциям
-// с колонкой владельца. Перечень живёт здесь одним списком: разойдясь с шагом
-// схемы, он оставил бы половину архива без защиты молча.
+// ownedCollections — коллекции с колонкой владельца. Перечень живёт здесь одним
+// списком, и разойтись с шагом схемы ему нельзя: пропущенная коллекция
+// пропускает удаление вперёд, а наружу приезжает не наш отказ с причиной, а
+// подсказка библиотеки про обязательную связь — та самая, по которой владелец
+// панели пойдёт удалять записи руками.
+//
+// Так уже случилось однажды: `topics` завелась третьей и в списке не появилась.
+var ownedCollections = []string{
+	migrations.RecordsCollection,
+	migrations.FilesCollection,
+	migrations.TopicsCollection,
+}
+
+// countOwned считает всё, что принадлежит учётной записи, — по всем коллекциям
+// с колонкой владельца.
 func countOwned(app core.App, ownerID string) (int64, error) {
 	var total int64
 
-	for _, collection := range []string{migrations.JobsCollection, migrations.FilesCollection} {
+	for _, collection := range ownedCollections {
 		count, err := app.CountRecords(collection, dbx.HashExp{"owner": ownerID})
 		if err != nil {
 			return 0, fmt.Errorf("failed to count owned records in %s: %w", collection, err)

internal/adapter/repo/pocketbase/owner_test.go

@@ -4,179 +4,134 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/google/uuid"
 	"github.com/pocketbase/pocketbase/core"
-	"github.com/pocketbase/pocketbase/tools/router"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
 	"git.vakhrushev.me/av/transcriber/internal/adapter/repo/pocketbase/migrations"
+	"git.vakhrushev.me/av/transcriber/internal/clock"
 	"git.vakhrushev.me/av/transcriber/internal/contract"
 	"git.vakhrushev.me/av/transcriber/internal/entity"
 )
 
-// newAccount заводит учётную запись и отдаёт её идентификатор.
-func newAccount(t *testing.T, app core.App, email string) string {
+// Страж удаления учётной записи — единственное, что стоит между владельцем
+// панели и молчаливым обезличиванием чужого архива: при выключенном каскаде
+// хранилище снимает ссылку и сохраняет запись без проверок.
+
+func newAccount(t *testing.T, app core.App) *core.Record {
 	t.Helper()
 
 	users, err := app.FindCollectionByNameOrId(migrations.UsersCollection)
 	require.NoError(t, err)
 
 	record := core.NewRecord(users)
-	record.Set("email", email)
+	record.Set("email", uuid.NewString()+"@example.test")
 	record.Set("verified", true)
-	record.SetRandomPassword()
+	record.Set("password", uuid.NewString())
 	require.NoError(t, app.Save(record))
 
-	return record.Id
+	return record
 }
 
-// Колонка владельца заводится шагом схемы на чистой базе, и умолчания у неё нет.
-func TestOwnerColumnHasNoDefault(t *testing.T) {
-	app := newTestApp(t)
+// newRecordOf заводит аудиозапись названного владельца.
+func newRecordOf(t *testing.T, app core.App, ownerID string) *entity.AudioRecord {
+	t.Helper()
 
-	for _, name := range []string{migrations.JobsCollection, migrations.FilesCollection} {
-		collection, err := app.FindCollectionByNameOrId(name)
-		require.NoError(t, err)
-
-		field := collection.Fields.GetByName("owner")
-		require.NotNil(t, field, "колонка владельца заведена в %s", name)
-
-		relation, ok := field.(*core.RelationField)
-		require.True(t, ok, "владелец — связь с учётной записью, а не строка")
-		assert.False(t, relation.Required, "пустое значение допустимо ради записей бота")
-		assert.False(t, relation.CascadeDelete, "удаление учётной записи не уносит записи")
-
-		// Умолчания у связи нет по устройству: запись, чей владелец не назван,
-		// не достаётся никому по недосмотру схемы.
-		record := core.NewRecord(collection)
-		assert.Empty(t, record.GetString("owner"), "новая запись приходит без владельца")
+	record := &entity.AudioRecord{
+		State:          entity.StateUploaded,
+		StateEnteredAt: clock.Now(),
+		Source:         entity.SourceApi,
 	}
-}
-
-// Чужая задача, ничья и несуществующая дают одну и ту же ошибку.
-func TestGetByID_NarrowedByOwner(t *testing.T) {
-	app := newTestApp(t)
-	repo := NewTranscriptJobRepository(app)
-
-	mine := newAccount(t, app, "mine@example.com")
-	stranger := newAccount(t, app, "stranger@example.com")
-
-	owned := newJob(t, repo, entity.StateCreated)
-	owned.OwnerID = &mine
-	require.NoError(t, repo.Save(owned, ""))
-	// Владельца кладёт заведение, а не сохранение конвейера, — ставим его прямо.
-	record, err := app.FindRecordById(migrations.JobsCollection, owned.Id)
-	require.NoError(t, err)
-	record.Set("owner", mine)
-	require.NoError(t, app.Save(record))
-
-	ownerless := newJob(t, repo, entity.StateCreated)
-
-	got, err := repo.GetByID(owned.Id, mine)
-	require.NoError(t, err, "своя задача отдаётся")
-	assert.Equal(t, owned.Id, got.Id)
-
-	_, foreignErr := repo.GetByID(owned.Id, stranger)
-	_, ownerlessErr := repo.GetByID(ownerless.Id, mine)
-	_, missingErr := repo.GetByID("nonexistent0000", mine)
-
-	var notFound *contract.JobNotFoundError
-	require.ErrorAs(t, foreignErr, &notFound, "чужая задача не отдаётся")
-	require.ErrorAs(t, ownerlessErr, &notFound, "ничья задача не отдаётся")
-	require.ErrorAs(t, missingErr, &notFound, "несуществующая тоже")
-}
-
-// Пустой владелец не совпадает ни с чем: ни со своей задачей, ни с чужой, ни с
-// ничьей. Правило записано со стороны спрашивающего — обязательность, которую
-// держит одна лишь подпись метода, пустую строку пропускает.
-func TestGetByID_EmptyOwnerMatchesNothing(t *testing.T) {
-	app := newTestApp(t)
-	repo := NewTranscriptJobRepository(app)
-
-	owner := newAccount(t, app, "mine@example.com")
-
-	owned := newJob(t, repo, entity.StateCreated)
-	record, err := app.FindRecordById(migrations.JobsCollection, owned.Id)
-	require.NoError(t, err)
-	record.Set("owner", owner)
-	require.NoError(t, app.Save(record))
-
-	ownerless := newJob(t, repo, entity.StateCreated)
-
-	var notFound *contract.JobNotFoundError
-	for _, id := range []string{owned.Id, ownerless.Id, "nonexistent0000"} {
-		_, err := repo.GetByID(id, "")
-		require.ErrorAs(t, err, &notFound, "пустой владелец не открывает %s", id)
+	if ownerID != "" {
+		record.OwnerID = &ownerID
 	}
+	require.NoError(t, NewAudioRecordRepository(app).Create(record))
+	return record
 }
 
-// Удаление учётной записи с задачами отвергается: связь с выключенным каскадом
-// иначе снимает ссылку, и архив человека становится ничьим и недостижимым.
+// Учётная запись с архивом не удаляется, и отказ называет причину — иначе
+// наружу приезжает подсказка библиотеки про обязательную связь, по которой
+// владелец панели пойдёт удалять записи руками.
 func TestGuardOwnerDeletion(t *testing.T) {
-	// Страж вешает сама сборка хранилища — звать его отдельно не нужно и нельзя:
-	// второй вызов повесил бы второй слой.
-	app := newTestApp(t)
-	repo := NewTranscriptJobRepository(app)
+	app := newTestStorage(t)
 
-	withJobs := newAccount(t, app, "keeper@example.com")
-	empty := newAccount(t, app, "empty@example.com")
+	account := newAccount(t, app)
+	record := newRecordOf(t, app, account.Id)
 
-	job := newJob(t, repo, entity.StateCreated)
-	record, err := app.FindRecordById(migrations.JobsCollection, job.Id)
-	require.NoError(t, err)
-	record.Set("owner", withJobs)
-	require.NoError(t, app.Save(record))
+	err := app.Delete(account)
+	require.Error(t, err, "учётная запись с архивом не удаляется")
+	assert.Contains(t, err.Error(), "остались записи", "отказ называет причину")
 
-	keeper, err := app.FindRecordById(migrations.UsersCollection, withJobs)
-	require.NoError(t, err)
-
-	err = app.Delete(keeper)
-	require.Error(t, err, "учётная запись с задачами не удаляется")
-
-	// Отказ обязан быть ошибкой роутера, а не обычной: наружу библиотека
-	// пропускает только её, а всякую другую подменяет своим сообщением про
-	// обязательную связь — подсказкой, по которой владелец панели пойдёт удалять
-	// задачи и файлы руками. Проверяется поэтому тип и текст, а не сам факт
-	// отказа: на потерянном сообщении факт остаётся прежним.
-	var apiErr *router.ApiError
-	require.ErrorAs(t, err, &apiErr, "отказ доезжает до владельца панели")
-	assert.Contains(t, apiErr.Message, "остались записи",
-		"причина названа, а не подменена библиотечной")
-
-	// Задача и её владелец остались прежними.
-	after, err := app.FindRecordById(migrations.JobsCollection, job.Id)
-	require.NoError(t, err)
-	assert.Equal(t, withJobs, after.GetString("owner"), "владелец не снят")
-
-	free, err := app.FindRecordById(migrations.UsersCollection, empty)
-	require.NoError(t, err)
-	assert.NoError(t, app.Delete(free), "учётная запись без записей удаляется")
+	after, err := NewAudioRecordRepository(app).Get(record.Id)
+	require.NoError(t, err, "запись на месте")
+	require.NotNil(t, after.OwnerID, "и владелец у неё прежний")
+	assert.Equal(t, account.Id, *after.OwnerID)
 }
 
-// Файл переживает свою задачу: шаг конвейера заводит его до сохранения задачи, и
-// потерянный захват оставляет файл с владельцем и без ссылки. Считать одни
-// задачи значило бы отдать такое аудио на молчаливое обезличивание.
-func TestGuardOwnerDeletion_CountsFilesToo(t *testing.T) {
-	app := newTestApp(t)
-	repo := NewFileRepository(app)
+// Считаются все коллекции с владельцем, а не одни записи: файл переживает свою
+// запись, а тема живёт в словаре человека.
+func TestGuardOwnerDeletionCountsEveryOwnedCollection(t *testing.T) {
+	cases := map[string]func(t *testing.T, app core.App, ownerID string){
+		"аудиозапись": func(t *testing.T, app core.App, ownerID string) {
+			newRecordOf(t, app, ownerID)
+		},
+		"один файл без записи": func(t *testing.T, app core.App, ownerID string) {
+			repo := NewFileRepository(app)
+			work, err := repo.Stage(".mp3", strings.NewReader("запись"))
+			require.NoError(t, err)
+			defer func() { require.NoError(t, work.Close()) }()
 
-	owner := newAccount(t, app, "files@example.com")
+			_, err = repo.Create("sample.mp3", work, contract.FileMeta{Format: "mp3"}, ownerID)
+			require.NoError(t, err)
+		},
+		"одна тема словаря": func(t *testing.T, app core.App, ownerID string) {
+			topics, err := app.FindCollectionByNameOrId(migrations.TopicsCollection)
+			require.NoError(t, err)
 
-	work, err := repo.Stage(".ogg", strings.NewReader("запись"))
-	require.NoError(t, err)
-	defer func() { require.NoError(t, work.Close()) }()
+			topic := core.NewRecord(topics)
+			topic.Set("owner", ownerID)
+			topic.Set("name", "личная тема")
+			require.NoError(t, app.Save(topic))
+		},
+	}
 
-	_, err = repo.CreateLocal("sample.ogg", work, owner)
-	require.NoError(t, err)
+	for name, own := range cases {
+		t.Run(name, func(t *testing.T) {
+			app := newTestStorage(t)
+			account := newAccount(t, app)
+			own(t, app, account.Id)
 
-	record, err := app.FindRecordById(migrations.UsersCollection, owner)
+			err := app.Delete(account)
+			require.Error(t, err, "учётная запись с этим добром не удаляется")
+			assert.Contains(t, err.Error(), "остались записи",
+				"отказ наш, а не подсказка библиотеки про обязательную связь")
+		})
+	}
+}
+
+// Учётная запись, за которой ничего не числится, удаляется штатно: страж
+// заведён против потери архива, а не против удаления вообще.
+func TestGuardOwnerDeletionLetsEmptyAccountGo(t *testing.T) {
+	app := newTestStorage(t)
+
+	account := newAccount(t, app)
+	require.NoError(t, app.Delete(account), "пустая учётная запись удаляется")
+}
+
+// Умолчания у колонки владельца нет: запись, чей владелец не назван, не
+// достаётся никому по недосмотру схемы.
+func TestOwnerColumnHasNoDefault(t *testing.T) {
+	app := newTestStorage(t)
+
+	records, err := app.FindCollectionByNameOrId(migrations.RecordsCollection)
 	require.NoError(t, err)
 
-	err = app.Delete(record)
-	require.Error(t, err, "учётная запись с одними файлами тоже не удаляется")
+	field := records.Fields.GetByName("owner")
+	require.NotNil(t, field, "колонка владельца заведена")
 
-	after, err := app.FindAllRecords(migrations.FilesCollection)
-	require.NoError(t, err)
-	require.Len(t, after, 1)
-	assert.Equal(t, owner, after[0].GetString("owner"), "владелец файла не снят")
+	relation, ok := field.(*core.RelationField)
+	require.True(t, ok, "владелец — связь с учётной записью, а не строка")
+	assert.False(t, relation.Required, "пустое значение допустимо ради записей бота")
+	assert.False(t, relation.CascadeDelete, "удаление учётной записи не уносит архив следом")
 }

internal/adapter/repo/pocketbase/panel.go

@@ -4,35 +4,83 @@ import (
 	"github.com/pocketbase/pocketbase/core"
 
 	"git.vakhrushev.me/av/transcriber/internal/adapter/repo/pocketbase/migrations"
+	"git.vakhrushev.me/av/transcriber/internal/entity"
 )
 
-// BindPanelRules подчиняет правку задачи в панели тем же правилам перехода, что
-// и правку из кода.
+// BindPanelRules подчиняет правку записи в панели тем же правилам, что и правку
+// из кода.
 //
-// Панель — вход в задачу наравне с конвейером, а не окно просмотра: ради правки
-// она и покупалась, мёртвая задача оживляется сменой состояния. Но правка полем
-// идёт мимо кода, который чистит служебные поля прошлого состояния, и владелец,
-// «вернувший задачу в работу», получил бы задачу с прежним признаком захвата
-// (захвату она не выдастся до конца срока) и с числом попыток на пределе (умрёт
-// от первого же отказа). Узнать об этом ему неоткуда.
+// Панель — вход в запись наравне с конвейером, а не окно просмотра: ради правки
+// она и покупалась, остановленная запись возвращается в работу снятием признака.
+// Но правка полем идёт мимо кода, который чистит служебные поля, и владелец,
+// «вернувший запись в работу», получил бы запись с прежним признаком захвата
+// (захвату она не выдастся до конца срока), с числом отказов на пределе
+// (остановится от первого же отказа) и со старым временем входа в рубеж
+// (остановится снова первым же захватом по пределу простоя). Узнать об этом ему
+// неоткуда.
+//
+// Правило живёт **одним местом** — доменными `Resume` и `MoveToState`, — и хук
+// зовёт именно их, а не повторяет перечень служебных полей колонками. Повтор
+// перечня был бы вторым домом того же правила: новый сторож попал бы в домен и
+// не попал в панель, и владелец «вернул бы запись в работу», а она снова выпала
+// бы из выборки — молча.
 //
 // Хук стоит на правке **запросом**, а не на всяком сохранении записи. Модельное
 // событие не различает, кто пишет, и срабатывало бы на каждом переходе
-// конвейера: тогда задержка, поставленная шагом вместе со сменой состояния,
-// стиралась бы тем же сохранением, а число попыток мёртвой задачи — которое
-// переход хранит намеренно — приходило бы владельцу нулём.
+// конвейера: тогда пауза, поставленная шагом вместе со сменой рубежа, стиралась
+// бы тем же сохранением, а число отказов остановленной записи — которое
+// остановка хранит намеренно — приходило бы владельцу нулём.
 func BindPanelRules(app core.App) {
-	app.OnRecordUpdateRequest(migrations.JobsCollection).BindFunc(func(e *core.RecordRequestEvent) error {
+	app.OnRecordUpdateRequest(migrations.RecordsCollection).BindFunc(func(e *core.RecordRequestEvent) error {
 		original := e.Record.Original()
-		if original == nil || original.GetString("state") == e.Record.GetString("state") {
+		if original == nil {
 			return e.Next()
 		}
 
-		e.Record.Set("acquisition_id", "")
-		e.Record.Set("acquire_time", "")
-		e.Record.Set("delay_time", "")
-		e.Record.Set("attempts", 0)
+		stateChanged := original.GetString("state") != e.Record.GetString("state")
+		// Снятие признака остановки — то самое движение, ради которого признак и
+		// заведён: запись возвращается в работу с сохранённого рубежа.
+		resumed := !original.GetDateTime("halted_at").IsZero() &&
+			e.Record.GetDateTime("halted_at").IsZero()
 
-		return e.Next()
+		if !stateChanged && !resumed {
+			return e.Next()
+		}
+
+		// Запись читается уже с правкой человека: рубеж здесь тот, который он
+		// выбрал, а признак остановки — тот, который он снял или оставил.
+		record := recordToAudioRecord(e.Record)
+		switch {
+		case resumed:
+			record.Resume()
+		default:
+			record.MoveToState(record.State)
+		}
+		applyOwnedByPipeline(e.Record, record)
+
+		if err := e.Next(); err != nil {
+			return err
+		}
+
+		if resumed {
+			// Перезапуск виден в журнале событий с указанием, что его сделал
+			// человек: иначе запись, вернувшаяся в работу, выглядела бы как
+			// запись, которая туда и не уходила.
+			//
+			// Строка пишется **после** сохранения: событие о правке, которая не
+			// прошла, соврало бы о состоянии записи. Отказ записи журнала саму
+			// правку не отменяет — журнал никем не читается ради решения.
+			event := &entity.RecordEvent{
+				RecordID: e.Record.Id,
+				Origin:   entity.EventOriginHuman,
+				Step:     "resume",
+				Outcome:  entity.EventOutcomeResumed,
+			}
+			if err := NewRecordEventRepository(e.App).Append(event); err != nil {
+				e.App.Logger().Error("Failed to log record resume", "error", err, "record_id", e.Record.Id)
+			}
+		}
+
+		return nil
 	})
 }

internal/adapter/repo/pocketbase/panel_test.go

@@ -0,0 +1,240 @@
+package pocketbase
+
+import (
+	"testing"
+	"time"
+
+	"github.com/pocketbase/pocketbase/core"
+	"github.com/pocketbase/pocketbase/tools/types"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"git.vakhrushev.me/av/transcriber/internal/adapter/repo/pocketbase/migrations"
+	"git.vakhrushev.me/av/transcriber/internal/clock"
+	"git.vakhrushev.me/av/transcriber/internal/entity"
+)
+
+// Панель — единственный сегодня путь вернуть остановленную запись в работу, и
+// хук правил стоит на правке **запросом**. Модельное сохранение его не трогает,
+// поэтому проверки ниже идут через запрос — иначе они зеленели бы, не касаясь
+// того пути, которым владелец и ходит.
+
+// newPanelStorage поднимает хранилище с повешенными правилами панели — так же,
+// как это делает сборка сервиса. Без них проверки судили бы хранилище без
+// правил, то есть не то, что работает в проде.
+func newPanelStorage(t *testing.T) core.App {
+	t.Helper()
+
+	app := newTestStorage(t)
+	BindPanelRules(app)
+	return app
+}
+
+// updateByRequest правит запись так, как это делает панель: запросом, а не
+// сохранением модели.
+func updateByRequest(t *testing.T, app core.App, recordID string, body map[string]any) *core.Record {
+	t.Helper()
+
+	record, err := app.FindRecordById(migrations.RecordsCollection, recordID)
+	require.NoError(t, err)
+
+	// Запись, прочитанная из хранилища, помнит прежние значения сама — по ним
+	// хук и отличает смену рубежа от правки соседнего поля.
+	for key, value := range body {
+		record.Set(key, value)
+	}
+
+	// Событие правки запросом несёт и запрос, и коллекцию: `RequestEvent` вложен
+	// указателем, а по коллекции хук и отбирается — без неё он не сработает вовсе,
+	// и проверка зеленела бы, не коснувшись правила.
+	collection, err := app.FindCollectionByNameOrId(migrations.RecordsCollection)
+	require.NoError(t, err)
+
+	event := &core.RecordRequestEvent{RequestEvent: &core.RequestEvent{}}
+	event.App = app
+	event.Collection = collection
+	event.Record = record
+
+	require.NoError(t, app.OnRecordUpdateRequest(migrations.RecordsCollection).Trigger(event, func(e *core.RecordRequestEvent) error {
+		return e.App.Save(e.Record)
+	}))
+
+	after, err := app.FindRecordById(migrations.RecordsCollection, recordID)
+	require.NoError(t, err)
+	return after
+}
+
+// haltedRecord заводит остановленную запись со всеми накопленными сторожами —
+// такой её видит владелец, открывая панель.
+func haltedRecord(t *testing.T, app core.App) *entity.AudioRecord {
+	t.Helper()
+
+	record := newRecordOf(t, app, "")
+	record.MoveToState(entity.StateNormalized)
+	record.Attempts = 4
+	record.AcquisitionID = ptrOf("прежний-захват")
+	record.AcquireExpiresAt = ptrOf(clock.Now().Add(8 * time.Hour))
+	record.DelayTime = ptrOf(clock.Now().Add(time.Hour))
+	record.Halt(entity.HaltReasonStepFailed, "сбой конвертации файла")
+	// Время входа в рубеж отодвигаем: запись простояла остановленной дольше
+	// предела простоя, и это ровно тот случай, ради которого сторож сбрасывается.
+	record.StateEnteredAt = clock.Now().Add(-24 * time.Hour)
+
+	require.NoError(t, NewAudioRecordRepository(app).Save(record, ""))
+	return record
+}
+
+func ptrOf[T any](v T) *T { return &v } //nolint:newexpr // значение вычисляется, new(x) его не примет
+
+// Снятие признака остановки возвращает запись в работу с сохранённого рубежа и
+// сбрасывает **всех** сторожей. Без сброса времени входа в рубеж запись,
+// простоявшая остановленной дольше предела, остановилась бы снова первым же
+// захватом — и владелец не узнал бы об этом.
+func TestPanelResumeClearsEveryGuard(t *testing.T) {
+	app := newPanelStorage(t)
+	record := haltedRecord(t, app)
+
+	after := updateByRequest(t, app, record.Id, map[string]any{"halted_at": ""})
+
+	assert.Equal(t, entity.StateNormalized, after.GetString("state"), "рубеж сохранён")
+	assert.True(t, after.GetDateTime("halted_at").IsZero(), "признак остановки снят")
+	assert.Empty(t, after.GetString("halt_reason"), "причина снята вместе с ним")
+	assert.Empty(t, after.GetString("error_text"), "и текст отказа")
+	assert.Empty(t, after.GetString("acquisition_id"), "признак прежнего захвата очищен")
+	assert.True(t, after.GetDateTime("acquire_expires_at").IsZero(), "срок протухания тоже")
+	assert.True(t, after.GetDateTime("delay_time").IsZero(), "пауза снята")
+	assert.Equal(t, 0, after.GetInt("attempts"), "отказы сброшены")
+
+	entered := after.GetDateTime("state_entered_at").Time()
+	assert.WithinDuration(t, clock.Now(), entered, time.Minute,
+		"время входа в рубеж поставлено заново: иначе сторож простоя остановит запись снова")
+
+	// И ближайший захват её выдаёт — то есть перезапуск действительно работает.
+	acquired, err := NewAudioRecordRepository(app).FindAndAcquire(entity.WorkingStages())
+	require.NoError(t, err, "запись вернулась в выборку")
+	assert.Equal(t, record.Id, acquired.ID)
+}
+
+// Перезапуск виден в журнале событий с указанием, что его сделал человек: иначе
+// запись, вернувшаяся в работу, выглядела бы как запись, которая туда и не
+// уходила.
+func TestPanelResumeIsLogged(t *testing.T) {
+	app := newPanelStorage(t)
+	record := haltedRecord(t, app)
+
+	updateByRequest(t, app, record.Id, map[string]any{"halted_at": ""})
+
+	events, err := app.FindAllRecords(migrations.RecordEventsCollection)
+	require.NoError(t, err)
+
+	var human int
+	for _, event := range events {
+		if event.GetString("record") == record.Id && event.GetString("origin") == entity.EventOriginHuman {
+			human++
+			assert.Equal(t, entity.EventOutcomeResumed, event.GetString("outcome"))
+		}
+	}
+	assert.Equal(t, 1, human, "ровно одна строка о перезапуске человеком")
+}
+
+// Правка рубежа руками чистит служебные поля прошлого захвата так же, как
+// снятие остановки: иначе владелец, «вернувший запись в работу» сменой рубежа,
+// получит запись, которая не выдаётся захвату до конца прежнего срока.
+func TestPanelStateEditClearsGuards(t *testing.T) {
+	app := newPanelStorage(t)
+
+	record := newRecordOf(t, app, "")
+	record.Attempts = 4
+	record.AcquisitionID = ptrOf("прежний-захват")
+	record.AcquireExpiresAt = ptrOf(clock.Now().Add(8 * time.Hour))
+	require.NoError(t, NewAudioRecordRepository(app).Save(record, ""))
+
+	after := updateByRequest(t, app, record.Id, map[string]any{"state": entity.StateNormalized})
+
+	assert.Equal(t, entity.StateNormalized, after.GetString("state"))
+	assert.Empty(t, after.GetString("acquisition_id"))
+	assert.Equal(t, 0, after.GetInt("attempts"))
+}
+
+// Правка соседнего поля служебных полей не трогает: хук судит смену рубежа и
+// снятие остановки, а не всякое сохранение. Иначе владелец, поправивший
+// заголовок, снял бы захват у работающего шага.
+func TestPanelKeepsGuardsOnUnrelatedEdit(t *testing.T) {
+	app := newPanelStorage(t)
+
+	record := newRecordOf(t, app, "")
+	record.Attempts = 3
+	record.AcquisitionID = ptrOf("живой-захват")
+	require.NoError(t, NewAudioRecordRepository(app).Save(record, ""))
+
+	after := updateByRequest(t, app, record.Id, map[string]any{"title": "Разговор с бабушкой"})
+
+	assert.Equal(t, "Разговор с бабушкой", after.GetString("title"))
+	assert.Equal(t, "живой-захват", after.GetString("acquisition_id"), "захват работающего шага не снят")
+	assert.Equal(t, 3, after.GetInt("attempts"), "отказы не сброшены")
+}
+
+// Захват отдаёт идентификатор и признак **этого** захвата, а срок протухания
+// приезжает с рубежом: воркер не привязан к шагу и вывести срок из себя не
+// может.
+func TestAcquireCarriesStageDeadline(t *testing.T) {
+	app := newTestStorage(t)
+	repo := NewAudioRecordRepository(app)
+
+	record := newRecordOf(t, app, "")
+
+	acquired, err := repo.FindAndAcquire(entity.WorkingStages())
+	require.NoError(t, err)
+	require.Equal(t, record.Id, acquired.ID)
+	require.NotEmpty(t, acquired.Holder)
+
+	stored, err := app.FindRecordById(migrations.RecordsCollection, record.Id)
+	require.NoError(t, err)
+	assert.Equal(t, acquired.Holder, stored.GetString("acquisition_id"))
+
+	stage, ok := entity.StageByName(entity.StateUploaded)
+	require.True(t, ok)
+	expected := clock.Now().Add(stage.AcquireTimeout)
+	assert.WithinDuration(t, expected, stored.GetDateTime("acquire_expires_at").Time(), time.Minute,
+		"срок протухания приехал с рубежа записи")
+}
+
+// Одна запись достаётся ровно одному захвату: на этом стоит инвариант «Принятая
+// запись не теряется молча».
+func TestAcquireHandsRecordToExactlyOne(t *testing.T) {
+	app := newTestStorage(t)
+	repo := NewAudioRecordRepository(app)
+
+	newRecordOf(t, app, "")
+
+	first, err := repo.FindAndAcquire(entity.WorkingStages())
+	require.NoError(t, err, "первому запись досталась")
+	require.NotEmpty(t, first.Holder)
+
+	for range 2 {
+		_, err = repo.FindAndAcquire(entity.WorkingStages())
+		require.Error(t, err, "остальным — признак «работы нет»")
+	}
+}
+
+// Протухший захват возвращает запись в работу, и признак нового захвата
+// отличается от прежнего: условие записи результата сверяет именно значение.
+func TestRottenAcquisitionIsHandedOutAgain(t *testing.T) {
+	app := newTestStorage(t)
+	repo := NewAudioRecordRepository(app)
+
+	record := newRecordOf(t, app, "")
+
+	first, err := repo.FindAndAcquire(entity.WorkingStages())
+	require.NoError(t, err)
+
+	stored, err := app.FindRecordById(migrations.RecordsCollection, record.Id)
+	require.NoError(t, err)
+	stored.Set("acquire_expires_at", types.NowDateTime().Add(-time.Hour))
+	require.NoError(t, app.Save(stored))
+
+	second, err := repo.FindAndAcquire(entity.WorkingStages())
+	require.NoError(t, err, "протухший захват не мешает выдать запись следующему")
+	assert.Equal(t, record.Id, second.ID)
+	assert.NotEqual(t, first.Holder, second.Holder, "признак нового захвата отличается от прежнего")
+}

internal/adapter/repo/pocketbase/recognition_repo.go

@@ -0,0 +1,161 @@
+package pocketbase
+
+import (
+	"errors"
+	"fmt"
+	"io"
+
+	"github.com/pocketbase/pocketbase/core"
+	"github.com/pocketbase/pocketbase/tools/filesystem"
+
+	"git.vakhrushev.me/av/transcriber/internal/adapter/repo/pocketbase/migrations"
+	"git.vakhrushev.me/av/transcriber/internal/clock"
+	"git.vakhrushev.me/av/transcriber/internal/entity"
+)
+
+type RecognitionRepository struct {
+	app core.App
+}
+
+func NewRecognitionRepository(app core.App) *RecognitionRepository {
+	return &RecognitionRepository{app: app}
+}
+
+// Create заводит строку попытки **до** обращения к провайдеру.
+//
+// Порядок здесь несущий: окно между ответом провайдера и записью идентификатора
+// операции — то место, где теряется оплаченное. Заведённая заранее строка даёт
+// повторному шагу, чем проверить сделанное прежде, чем платить второй раз.
+func (repo *RecognitionRepository) Create(r *entity.Recognition) error {
+	collection, err := findCollection(repo.app, migrations.RecognitionsCollection)
+	if err != nil {
+		return err
+	}
+
+	started := clock.Now()
+	record := core.NewRecord(collection)
+	record.Set("record", r.RecordID)
+	record.Set("provider", r.Provider)
+	record.Set("model", r.Model)
+	record.Set("external_id", r.ExternalID)
+	record.Set("source_uri", r.SourceURI)
+	record.Set("started_at", dateOrEmpty(&started))
+
+	if err := repo.app.Save(record); err != nil {
+		return fmt.Errorf("failed to create recognition attempt for record %s: %w", r.RecordID, err)
+	}
+
+	r.Id = record.Id
+	r.StartedAt = &started
+	return nil
+}
+
+// Submitted сохраняет адрес аудио и идентификатор заведённой операции. По
+// последнему повторный шаг узнаёт, что за эту запись уже заплачено, и второй раз
+// наружу не платит.
+func (repo *RecognitionRepository) Submitted(id, sourceURI, externalID string) error {
+	record, err := repo.app.FindRecordById(migrations.RecognitionsCollection, id)
+	if err != nil {
+		return fmt.Errorf("failed to find recognition attempt %s: %w", id, err)
+	}
+	record.Set("source_uri", sourceURI)
+	record.Set("external_id", externalID)
+	if err := repo.app.Save(record); err != nil {
+		return fmt.Errorf("failed to store operation id of attempt %s: %w", id, err)
+	}
+	return nil
+}
+
+// Finish кладёт сырой ответ провайдера вложением и отмечает завершение.
+//
+// Вложением, а не колонкой: шаг опроса читает эту строку раз в несколько секунд,
+// а хранилище читает запись целиком — ответ на многочасовую запись ехал бы в
+// память при каждом опросе. Хранится он потому, что результат операции у
+// провайдера не переспрашивается.
+func (repo *RecognitionRepository) Finish(id string, raw []byte) error {
+	record, err := repo.app.FindRecordById(migrations.RecognitionsCollection, id)
+	if err != nil {
+		return fmt.Errorf("failed to find recognition attempt %s: %w", id, err)
+	}
+
+	if len(raw) > 0 {
+		// Имя вложения задаём мы: умолчание хранилища строит его из имени
+		// исходного файла, а имя, данное отправителем, в хранилище не попадает.
+		payload, err := filesystem.NewFileFromBytes(raw, id+".payload")
+		if err != nil {
+			return fmt.Errorf("failed to prepare provider payload of attempt %s", id)
+		}
+		record.Set("payload", payload)
+	}
+
+	finished := clock.Now()
+	record.Set("finished_at", dateOrEmpty(&finished))
+
+	if err := repo.app.Save(record); err != nil {
+		// Отказ хранилища несёт имя файла вложения целиком, а оно — последняя
+		// часть ссылки: цепочка `%w` уехала бы в журнал вместе с ним.
+		return fmt.Errorf("failed to store provider payload of attempt %s", id)
+	}
+	return nil
+}
+
+func (repo *RecognitionRepository) GetByID(id string) (*entity.Recognition, error) {
+	record, err := repo.app.FindRecordById(migrations.RecognitionsCollection, id)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get recognition attempt %s: %w", id, err)
+	}
+
+	return &entity.Recognition{
+		Id:         record.Id,
+		RecordID:   record.GetString("record"),
+		Provider:   record.GetString("provider"),
+		Model:      record.GetString("model"),
+		ExternalID: record.GetString("external_id"),
+		SourceURI:  record.GetString("source_uri"),
+		StartedAt:  timeOrNil(record.GetDateTime("started_at")),
+		FinishedAt: timeOrNil(record.GetDateTime("finished_at")),
+	}, nil
+}
+
+// ReadRaw отдаёт сохранённый ответ провайдера. Зовётся только тогда, когда ответ
+// нужен: шаг опроса читает строку попытки без него.
+func (repo *RecognitionRepository) ReadRaw(id string) ([]byte, error) {
+	record, err := repo.app.FindRecordById(migrations.RecognitionsCollection, id)
+	if err != nil {
+		return nil, fmt.Errorf("failed to find recognition attempt %s: %w", id, err)
+	}
+
+	names := record.GetStringSlice("payload")
+	if len(names) == 0 {
+		return nil, fmt.Errorf("recognition attempt %s has no stored payload", id)
+	}
+
+	fsys, err := repo.app.NewFilesystem()
+	if err != nil {
+		return nil, fmt.Errorf("failed to open storage filesystem: %w", err)
+	}
+
+	reader, err := fsys.GetReader(record.BaseFilesPath() + "/" + names[0])
+	if err != nil {
+		// Отказ хранилища несёт имя вложения целиком, а имя — последняя часть
+		// ссылки на скачивание: наружу идёт идентификатор попытки, и только он.
+		return nil, errors.Join(
+			fmt.Errorf("failed to read stored payload of attempt %s", id),
+			fsys.Close(),
+		)
+	}
+
+	raw, readErr := io.ReadAll(reader)
+	closeErr := errors.Join(reader.Close(), fsys.Close())
+	if readErr != nil {
+		return nil, errors.Join(
+			fmt.Errorf("failed to read stored payload of attempt %s", id),
+			closeErr,
+		)
+	}
+	if closeErr != nil {
+		return nil, closeErr
+	}
+
+	return raw, nil
+}

internal/adapter/repo/pocketbase/record_event_repo.go

@@ -0,0 +1,50 @@
+package pocketbase
+
+import (
+	"fmt"
+
+	"github.com/pocketbase/pocketbase/core"
+
+	"git.vakhrushev.me/av/transcriber/internal/adapter/repo/pocketbase/migrations"
+	"git.vakhrushev.me/av/transcriber/internal/entity"
+)
+
+type RecordEventRepository struct {
+	app core.App
+}
+
+func NewRecordEventRepository(app core.App) *RecordEventRepository {
+	return &RecordEventRepository{app: app}
+}
+
+// Append пишет строку журнала событий записи.
+//
+// Журнал пишется на смену рубежа, на остановку и на снятие остановки, а не на
+// каждое откладывание опроса: часовая запись дала бы сотни строк ни о чём. Ни
+// один шаг конвейера его не читает, чтобы решить, что делать дальше: решение
+// принимается по рубежу записи, и второй источник решения разошёлся бы с первым
+// молча.
+//
+// Содержимое записи сюда не попадает — инвариант приватности действует здесь
+// наравне с журналом сервиса.
+func (repo *RecordEventRepository) Append(event *entity.RecordEvent) error {
+	collection, err := findCollection(repo.app, migrations.RecordEventsCollection)
+	if err != nil {
+		return err
+	}
+
+	record := core.NewRecord(collection)
+	record.Set("record", event.RecordID)
+	record.Set("origin", event.Origin)
+	record.Set("step", event.Step)
+	record.Set("outcome", event.Outcome)
+	record.Set("outcome_text", event.OutcomeText)
+	record.Set("duration_ms", event.DurationMs)
+
+	if err := repo.app.Save(record); err != nil {
+		return fmt.Errorf("failed to append event of record %s: %w", event.RecordID, err)
+	}
+
+	event.Id = record.Id
+	return nil
+}

internal/adapter/repo/pocketbase/record_mapping.go

@@ -0,0 +1,151 @@
+package pocketbase
+
+import (
+	"time"
+
+	"github.com/pocketbase/pocketbase/core"
+	"github.com/pocketbase/pocketbase/tools/types"
+
+	"git.vakhrushev.me/av/transcriber/internal/entity"
+)
+
+// Отображение аудиозаписи в запись коллекции и обратно живёт одним местом.
+//
+// Мест стало **два** вместо прежних четырёх: захват больше не перечисляет
+// колонки поимённо, а возвращает идентификатор и признак своего захвата.
+// Инвариант проекта о колонках очереди этим съёживается и перестаёт расти с
+// моделью — иначе каждая новая колонка записи попадала бы под него.
+
+// applyOwnedByPipeline кладёт в запись только те поля, которыми распоряжается
+// конвейер. Поля, которые он не меняет никогда — владелец, вход, заголовок,
+// краткое описание, темы и адресат ответа, — не трогаются вовсе.
+//
+// Разрез нужен потому, что шаг держит запись снимком с момента захвата и до
+// своего сохранения, а это часы. Всё, что владелец правил в панели за это время,
+// безусловная запись снимка стёрла бы молча: ни строки в журнале, ни отказа в
+// панели — владелец видел бы успешное сохранение и был бы уверен, что правка на
+// месте.
+func applyOwnedByPipeline(record *core.Record, r *entity.AudioRecord) {
+	record.Set("state", r.State)
+	record.Set("state_entered_at", dateOrEmpty(&r.StateEnteredAt))
+	record.Set("halted_at", dateOrEmpty(r.HaltedAt))
+	record.Set("halt_reason", derefString(r.HaltReason))
+	record.Set("error_text", derefString(r.ErrorText))
+	record.Set("acquisition_id", derefString(r.AcquisitionID))
+	record.Set("acquire_expires_at", dateOrEmpty(r.AcquireExpiresAt))
+	record.Set("delay_time", dateOrEmpty(r.DelayTime))
+	record.Set("attempts", r.Attempts)
+	record.Set("original_file", derefString(r.OriginalFileID))
+	record.Set("normalized_file", derefString(r.NormalizedFileID))
+	record.Set("transcript_text", derefString(r.TranscriptTextID))
+	record.Set("literary_text", derefString(r.LiteraryTextID))
+	record.Set("structure", derefString(r.StructureID))
+	record.Set("recognition", derefString(r.RecognitionID))
+}
+
+// applyToRecord кладёт запись целиком — это заведение, и спорить за поля здесь
+// не с кем.
+func applyToRecord(record *core.Record, r *entity.AudioRecord) {
+	applyOwnedByPipeline(record, r)
+	// Владелец кладётся только здесь, при заведении. В applyOwnedByPipeline его
+	// нет намеренно: конвейер владельца не назначает и не меняет, а снимок шага,
+	// записанный поверх, стёр бы его молча.
+	record.Set("owner", derefString(r.OwnerID))
+	record.Set("source", r.Source)
+	record.Set("title", derefString(r.Title))
+	record.Set("brief", derefString(r.Brief))
+	record.Set("tg_chat_id", derefInt64(r.TgChatId))
+	record.Set("tg_reply_message_id", derefInt(r.TgReplyMessageId))
+}
+
+func recordToAudioRecord(record *core.Record) *entity.AudioRecord {
+	return &entity.AudioRecord{
+		Id:               record.Id,
+		OwnerID:          nilIfEmpty(record.GetString("owner")),
+		Source:           record.GetString("source"),
+		Title:            nilIfEmpty(record.GetString("title")),
+		Brief:            nilIfEmpty(record.GetString("brief")),
+		State:            record.GetString("state"),
+		StateEnteredAt:   record.GetDateTime("state_entered_at").Time(),
+		HaltedAt:         timeOrNil(record.GetDateTime("halted_at")),
+		HaltReason:       nilIfEmpty(record.GetString("halt_reason")),
+		ErrorText:        nilIfEmpty(record.GetString("error_text")),
+		AcquisitionID:    nilIfEmpty(record.GetString("acquisition_id")),
+		AcquireExpiresAt: timeOrNil(record.GetDateTime("acquire_expires_at")),
+		DelayTime:        timeOrNil(record.GetDateTime("delay_time")),
+		Attempts:         record.GetInt("attempts"),
+		OriginalFileID:   nilIfEmpty(record.GetString("original_file")),
+		NormalizedFileID: nilIfEmpty(record.GetString("normalized_file")),
+		TranscriptTextID: nilIfEmpty(record.GetString("transcript_text")),
+		LiteraryTextID:   nilIfEmpty(record.GetString("literary_text")),
+		StructureID:      nilIfEmpty(record.GetString("structure")),
+		RecognitionID:    nilIfEmpty(record.GetString("recognition")),
+		TgChatId:         nilIfZero64(int64(record.GetInt("tg_chat_id"))),
+		TgReplyMessageId: nilIfZeroInt(record.GetInt("tg_reply_message_id")),
+		CreatedAt:        record.GetDateTime("created").Time(),
+		UpdatedAt:        record.GetDateTime("updated").Time(),
+	}
+}
+
+func derefString(v *string) string {
+	if v == nil {
+		return ""
+	}
+	return *v
+}
+
+func derefInt64(v *int64) int64 {
+	if v == nil {
+		return 0
+	}
+	return *v
+}
+
+func derefInt(v *int) int {
+	if v == nil {
+		return 0
+	}
+	return *v
+}
+
+// dateOrEmpty отдаёт пустое значение вместо нулевой даты: пустая колонка даты в
+// хранилище это пустая строка, и она же значит «времени нет».
+func dateOrEmpty(v *time.Time) any {
+	if v == nil || v.IsZero() {
+		return ""
+	}
+	date, err := types.ParseDateTime(*v)
+	if err != nil {
+		return ""
+	}
+	return date
+}
+
+func nilIfEmpty(v string) *string {
+	if v == "" {
+		return nil
+	}
+	return &v
+}
+
+func timeOrNil(v types.DateTime) *time.Time {
+	if v.IsZero() {
+		return nil
+	}
+	t := v.Time()
+	return &t
+}
+
+func nilIfZero64(v int64) *int64 {
+	if v == 0 {
+		return nil
+	}
+	return &v
+}
+
+func nilIfZeroInt(v int) *int {
+	if v == 0 {
+		return nil
+	}
+	return &v
+}

internal/adapter/repo/pocketbase/record_repo.go

@@ -0,0 +1,235 @@
+package pocketbase
+
+import (
+	"database/sql"
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/google/uuid"
+	"github.com/pocketbase/dbx"
+	"github.com/pocketbase/pocketbase/core"
+	"github.com/pocketbase/pocketbase/tools/types"
+
+	"git.vakhrushev.me/av/transcriber/internal/contract"
+	"git.vakhrushev.me/av/transcriber/internal/entity"
+
+	"git.vakhrushev.me/av/transcriber/internal/adapter/repo/pocketbase/migrations"
+
+	"git.vakhrushev.me/av/transcriber/internal/clock"
+)
+
+type AudioRecordRepository struct {
+	app core.App
+}
+
+func NewAudioRecordRepository(app core.App) *AudioRecordRepository {
+	return &AudioRecordRepository{app: app}
+}
+
+func (repo *AudioRecordRepository) Create(r *entity.AudioRecord) error {
+	collection, err := findCollection(repo.app, migrations.RecordsCollection)
+	if err != nil {
+		return err
+	}
+
+	record := core.NewRecord(collection)
+	if r.Id != "" {
+		record.Id = r.Id
+	}
+	applyToRecord(record, r)
+
+	if err := repo.app.Save(record); err != nil {
+		return fmt.Errorf("failed to insert audio record: %w", err)
+	}
+
+	r.Id = record.Id
+	r.CreatedAt = record.GetDateTime("created").Time()
+	r.UpdatedAt = record.GetDateTime("updated").Time()
+
+	return nil
+}
+
+// Save сохраняет запись, захват которой держит holder. Проверка и запись идут
+// одной транзакцией: шаг, потерявший запись за время работы, получает
+// LostAcquisitionError и результата не пишет.
+//
+// Сверяется **значение** признака захвата, а не занятость записи. Захват,
+// перевыданный другому — по протуханию срока или после того, как человек снял
+// признак остановки в панели, — обязан обратить запись первого в отказ; условие
+// по непустоте признака пропустило бы обоих, и два шага записали бы в одну
+// запись и оба ответили бы отправителю.
+func (repo *AudioRecordRepository) Save(r *entity.AudioRecord, holder string) error {
+	return repo.app.RunInTransaction(func(txApp core.App) error {
+		record, err := txApp.FindRecordById(migrations.RecordsCollection, r.Id)
+		if err != nil {
+			return fmt.Errorf("failed to find audio record: %w", err)
+		}
+
+		if holder != "" && record.GetString("acquisition_id") != holder {
+			return &contract.LostAcquisitionError{JobID: r.Id}
+		}
+
+		// Кладём только то, чем распоряжается конвейер: правку владельца в
+		// панели снимок шага стирать не должен.
+		applyOwnedByPipeline(record, r)
+
+		if err := txApp.Save(record); err != nil {
+			return fmt.Errorf("failed to update audio record: %w", err)
+		}
+
+		r.UpdatedAt = record.GetDateTime("updated").Time()
+		return nil
+	})
+}
+
+// GetByID отдаёт запись, только если её владелец — ownerID.
+//
+// Чужая запись, запись без владельца и несуществующая дают одну и ту же ошибку:
+// по разнице ответов иначе перебирается список заведённых записей, а
+// идентификатор записи и есть то, что разграничение прячет.
+//
+// Пустой ownerID отсекается **до** чтения и не совпадает ни с чем: иначе
+// вызывающий без учётной записи получил бы ровно множество записей без
+// владельца, то есть все записи бота.
+func (repo *AudioRecordRepository) GetByID(id, ownerID string) (*entity.AudioRecord, error) {
+	if ownerID == "" {
+		return nil, &contract.JobNotFoundError{Message: "record not found"}
+	}
+
+	record, err := repo.find(id)
+	if err != nil {
+		return nil, err
+	}
+
+	if record.GetString("owner") != ownerID {
+		return nil, &contract.JobNotFoundError{Message: "record not found"}
+	}
+
+	return recordToAudioRecord(record), nil
+}
+
+// Get отдаёт запись без сужения владельцем: им пользуется конвейер, чья выборка
+// владельцем не сужается.
+func (repo *AudioRecordRepository) Get(id string) (*entity.AudioRecord, error) {
+	record, err := repo.find(id)
+	if err != nil {
+		return nil, err
+	}
+	return recordToAudioRecord(record), nil
+}
+
+func (repo *AudioRecordRepository) find(id string) (*core.Record, error) {
+	record, err := repo.app.FindRecordById(migrations.RecordsCollection, id)
+	if err != nil {
+		// «Такой записи нет» переводится в доменную ошибку **здесь**, у
+		// источника, как велит конвенция об ошибках. Иначе три исхода, которые
+		// разграничение обязано сделать неразличимыми, разъезжаются: чужая и
+		// ничья записи дают доменную ошибку, а несуществующая — отказ базы,
+		// неотличимый от настоящей аварии хранилища.
+		if errors.Is(err, sql.ErrNoRows) {
+			return nil, &contract.JobNotFoundError{Message: "record not found"}
+		}
+		return nil, fmt.Errorf("failed to get audio record: %w", err)
+	}
+	return record, nil
+}
+
+// FindAndAcquire забирает пригодную к работе запись одним неделимым шагом:
+// выбор подходящей и пометка её захваченной идут вместе.
+//
+// Возвращается **идентификатор и признак этого захвата**, а не перечень колонок.
+// Колонки шаг читает обычным чтением: иначе всякая новая колонка записи попадала
+// бы под инвариант проекта о колонках очереди, а забытая приезжала бы нулевой, и
+// первое же сохранение писало бы этот ноль поверх сохранённого значения.
+//
+// Срок протухания захвата приезжает **с рубежом**, а не с воркером: воркер не
+// привязан к шагу и не знает заранее, что вытянет. Перечень рубежей и их сроков
+// приходит одним дескриптором — перечислять их порознь нельзя: рубеж, забытый в
+// отборе, не выдаётся ни одному воркеру никогда, а пустой прогон по инварианту
+// проекта не пишется в журнал и не считается в метрику.
+//
+// Запрос идёт сырым, мимо записей коллекции: `app.DB()` направляет всё, кроме
+// выборок, в пул с единственным соединением, и захваты выстраиваются в очередь.
+// Хуки коллекции на нём не срабатывают, поэтому время изменения проставляет сам
+// запрос.
+//
+// Все времена кладутся и сравниваются тем же видом, каким хранилище пишет свои
+// `created`/`updated`: сравнение строк побайтово, и вид, разошедшийся хоть
+// разделителем, обратил бы условие срока в постоянную истину или постоянную
+// ложь — молча.
+func (repo *AudioRecordRepository) FindAndAcquire(stages []entity.Stage) (*contract.AcquiredRecord, error) {
+	if len(stages) == 0 {
+		return nil, &contract.JobNotFoundError{Message: "no working stages declared"}
+	}
+
+	// Метка времени берётся единой точкой, а не `types.NowDateTime()`: обёртка
+	// хранилища читает часы сама, и запрет линтера её не видит — новая метка в
+	// этом запросе обошла бы единую точку молча.
+	now, err := types.ParseDateTime(clock.Now())
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse current time: %w", err)
+	}
+
+	holder := uuid.NewString()
+	params := dbx.Params{
+		"holder": holder,
+		"now":    now.String(),
+	}
+
+	// Срок протухания у каждого рубежа свой, поэтому он выбирается по рубежу
+	// самой записи прямо в запросе: воркер, ещё не знающий, что вытянет,
+	// подставить его не может.
+	var expiry strings.Builder
+	expiry.WriteString("CASE state")
+	var states []string
+	for i, stage := range stages {
+		stateKey := fmt.Sprintf("state%d", i)
+		expiryKey := fmt.Sprintf("expiry%d", i)
+
+		deadline, err := types.ParseDateTime(clock.Now().Add(stage.AcquireTimeout))
+		if err != nil {
+			return nil, fmt.Errorf("failed to parse acquire deadline: %w", err)
+		}
+
+		fmt.Fprintf(&expiry, " WHEN {:%s} THEN {:%s}", stateKey, expiryKey)
+		params[stateKey] = stage.Name
+		params[expiryKey] = deadline.String()
+		states = append(states, "{:"+stateKey+"}")
+	}
+	expiry.WriteString(" END")
+
+	table := "{{" + migrations.RecordsCollection + "}}"
+	query := repo.app.DB().NewQuery(`
+		UPDATE ` + table + `
+		   SET acquisition_id = {:holder},
+		       acquire_expires_at = ` + expiry.String() + `,
+		       attempts = attempts + 1,
+		       updated = {:now}
+		 WHERE id = (
+		       SELECT id FROM ` + table + `
+		        WHERE state IN (` + strings.Join(states, ", ") + `)
+		          AND (halted_at = '' OR halted_at IS NULL)
+		          AND (delay_time = '' OR delay_time IS NULL OR delay_time < {:now})
+		          AND (acquisition_id = '' OR acquisition_id IS NULL
+		               OR acquire_expires_at = '' OR acquire_expires_at IS NULL
+		               OR acquire_expires_at < {:now})
+		        ORDER BY created, id
+		        LIMIT 1
+		 )
+		RETURNING id`)
+
+	query.Bind(params)
+
+	var row struct {
+		Id string `db:"id"`
+	}
+	if err := query.One(&row); err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			return nil, &contract.JobNotFoundError{Message: "no record is ready for work"}
+		}
+		return nil, fmt.Errorf("failed to acquire an audio record: %w", err)
+	}
+
+	return &contract.AcquiredRecord{ID: row.Id, Holder: holder}, nil
+}

internal/adapter/repo/pocketbase/schema_test.go

@@ -0,0 +1,110 @@
+package pocketbase
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/pocketbase/pocketbase/core"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"git.vakhrushev.me/av/transcriber/internal/adapter/repo/pocketbase/migrations"
+)
+
+// newTestStorage поднимает хранилище на пустом каталоге и накатывает схему —
+// тем же путём, каким это делает сервис при старте.
+func newTestStorage(t *testing.T) core.App {
+	t.Helper()
+
+	app, err := New(t.TempDir())
+	require.NoError(t, err)
+	t.Cleanup(func() {
+		if err := app.ResetBootstrapState(); err != nil {
+			t.Logf("не удалось закрыть хранилище: %v", err)
+		}
+	})
+
+	return app
+}
+
+// Критерий приёмки 10. Содержимое записи закрыто во всех коллекциях, куда оно
+// переехало.
+//
+// Прежде содержимое лежало одной колонкой задачи, и закрывала его одна норма про
+// файл записи. Теперь оно живёт в шести коллекциях, и реализация, следующая
+// только прежней норме, завела бы поле вложения с умолчанием библиотеки: ссылка
+// на сырой ответ провайдера — а это полный текст речи — отдавала бы его любому,
+// кто её знает, без сессии.
+func TestRecordContentIsClosedEverywhere(t *testing.T) {
+	app := newTestStorage(t)
+
+	// Правило просмотра остаётся незаданным, то есть «только владелец панели».
+	// Содержимое отдаёт собственный адрес сервиса, а не поверхность хранилища;
+	// непустое правило открыло бы перечисление коллекции впрок.
+	for _, name := range []string{
+		migrations.RecordsCollection,
+		migrations.TextsCollection,
+		migrations.StructuresCollection,
+		migrations.RecognitionsCollection,
+		migrations.RecordEventsCollection,
+		migrations.TopicsCollection,
+	} {
+		collection, err := app.FindCollectionByNameOrId(name)
+		require.NoError(t, err, "коллекция %s заведена шагом схемы", name)
+
+		assert.Nil(t, collection.ListRule, "перечисление %s закрыто", name)
+		assert.Nil(t, collection.ViewRule, "чтение %s закрыто", name)
+		assert.Nil(t, collection.CreateRule, "заведение записи в %s закрыто", name)
+		assert.Nil(t, collection.UpdateRule, "правка %s закрыта", name)
+		assert.Nil(t, collection.DeleteRule, "удаление из %s закрыто", name)
+	}
+
+	// А поле вложения помечено защищённым: без пометки ссылка открывает
+	// содержимое любому, кто её знает, и знание ссылки становится правом.
+	recognitions, err := app.FindCollectionByNameOrId(migrations.RecognitionsCollection)
+	require.NoError(t, err)
+
+	field := recognitions.Fields.GetByName("payload")
+	require.NotNil(t, field, "поле сохранённого ответа заведено")
+
+	file, ok := field.(*core.FileField)
+	require.True(t, ok, "сохранённый ответ лежит вложением, а не колонкой")
+	assert.True(t, file.Protected, "поле вложения защищено")
+}
+
+// Прежняя коллекция задач уходит вместе с моделью: данных под ней не было, а
+// пустая копия висела бы в панели вторым домом для понятия, которого больше нет.
+func TestFormerJobsCollectionIsGone(t *testing.T) {
+	app := newTestStorage(t)
+
+	_, err := app.FindCollectionByNameOrId(migrations.JobsCollection)
+	assert.Error(t, err, "прежней коллекции задач не осталось")
+}
+
+// Пара «запись и вид» уникальна: повтор прерванного шага не заводит второго
+// комплекта строк, и вопрос «какой текст отдавать человеку» не становится
+// вопросом порядка записи.
+func TestAppendicesAreUniquePerRecord(t *testing.T) {
+	app := newTestStorage(t)
+
+	indexes := map[string][]string{
+		migrations.TextsCollection:      {"idx_texts_record_kind"},
+		migrations.StructuresCollection: {"idx_structures_record_version"},
+		migrations.TopicsCollection:     {"idx_topics_owner_name"},
+	}
+
+	for name, expected := range indexes {
+		collection, err := app.FindCollectionByNameOrId(name)
+		require.NoError(t, err)
+
+		for _, index := range expected {
+			var found bool
+			for _, declared := range collection.Indexes {
+				if strings.Contains(declared, index) && strings.Contains(declared, "UNIQUE") {
+					found = true
+				}
+			}
+			assert.Truef(t, found, "у %s есть уникальный индекс %s", name, index)
+		}
+	}
+}

internal/adapter/repo/pocketbase/text_repo.go

@@ -0,0 +1,151 @@
+package pocketbase
+
+import (
+	"database/sql"
+	"encoding/json"
+	"errors"
+	"fmt"
+
+	"github.com/pocketbase/dbx"
+	"github.com/pocketbase/pocketbase/core"
+
+	"git.vakhrushev.me/av/transcriber/internal/adapter/repo/pocketbase/migrations"
+	"git.vakhrushev.me/av/transcriber/internal/entity"
+)
+
+type TextRepository struct {
+	app core.App
+}
+
+func NewTextRepository(app core.App) *TextRepository {
+	return &TextRepository{app: app}
+}
+
+// Put кладёт текст записи, заменяя прежний того же вида.
+//
+// Замена, а не вставка: пара «запись и вид» уникальна, и повтор прерванного шага
+// иначе завёл бы второй комплект строк — тогда вопрос «какой текст отдавать
+// человеку» стал бы вопросом порядка записи, а не состояния.
+func (repo *TextRepository) Put(recordID, kind, contents string) (*entity.Text, error) {
+	collection, err := findCollection(repo.app, migrations.TextsCollection)
+	if err != nil {
+		return nil, err
+	}
+
+	record, err := repo.app.FindFirstRecordByFilter(
+		migrations.TextsCollection,
+		"record = {:record} && kind = {:kind}",
+		dbx.Params{"record": recordID, "kind": kind},
+	)
+	switch {
+	case err == nil:
+		// Строка есть — заменяем содержимое.
+	case errors.Is(err, sql.ErrNoRows):
+		record = core.NewRecord(collection)
+		record.Set("record", recordID)
+		record.Set("kind", kind)
+	default:
+		// Отказ хранилища «строкой нет» не является, и подменять его вставкой
+		// нельзя: она упрётся в уникальный индекс, и наверх уедет жалоба на
+		// запись вместо правды о недоступной базе.
+		return nil, fmt.Errorf("failed to look up text of kind %s for record %s: %w", kind, recordID, err)
+	}
+	record.Set("contents", contents)
+
+	if err := repo.app.Save(record); err != nil {
+		// Текст расшифровки наружу не выходит даже отказом: цепочка `%w` от
+		// хранилища несёт значение поля.
+		return nil, fmt.Errorf("failed to store text of kind %s for record %s", kind, recordID)
+	}
+
+	return textFromRecord(record), nil
+}
+
+func (repo *TextRepository) GetByID(id string) (*entity.Text, error) {
+	record, err := repo.app.FindRecordById(migrations.TextsCollection, id)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get text %s: %w", id, err)
+	}
+	return textFromRecord(record), nil
+}
+
+func textFromRecord(record *core.Record) *entity.Text {
+	return &entity.Text{
+		Id:       record.Id,
+		RecordID: record.GetString("record"),
+		Kind:     record.GetString("kind"),
+		Contents: record.GetString("contents"),
+	}
+}
+
+type StructureRepository struct {
+	app core.App
+}
+
+func NewStructureRepository(app core.App) *StructureRepository {
+	return &StructureRepository{app: app}
+}
+
+// Put кладёт структуру реплик, заменяя прежнюю той же версии разбора. Довод тот
+// же, что и у текста: повтор шага не должен заводить второй строки.
+func (repo *StructureRepository) Put(recordID string, version int, replicas []entity.Replica) (*entity.Structure, error) {
+	collection, err := findCollection(repo.app, migrations.StructuresCollection)
+	if err != nil {
+		return nil, err
+	}
+
+	contents, err := json.Marshal(replicas)
+	if err != nil {
+		return nil, fmt.Errorf("failed to encode structure of record %s", recordID)
+	}
+
+	record, err := repo.app.FindFirstRecordByFilter(
+		migrations.StructuresCollection,
+		"record = {:record} && version = {:version}",
+		dbx.Params{"record": recordID, "version": version},
+	)
+	switch {
+	case err == nil:
+		// Строка есть — заменяем содержимое.
+	case errors.Is(err, sql.ErrNoRows):
+		record = core.NewRecord(collection)
+		record.Set("record", recordID)
+		record.Set("version", version)
+	default:
+		return nil, fmt.Errorf("failed to look up structure of record %s: %w", recordID, err)
+	}
+	record.Set("contents", string(contents))
+
+	if err := repo.app.Save(record); err != nil {
+		return nil, fmt.Errorf("failed to store structure of record %s", recordID)
+	}
+
+	return &entity.Structure{
+		Id:       record.Id,
+		RecordID: recordID,
+		Version:  version,
+		Replicas: replicas,
+	}, nil
+}
+
+func (repo *StructureRepository) GetByID(id string) (*entity.Structure, error) {
+	record, err := repo.app.FindRecordById(migrations.StructuresCollection, id)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get structure %s: %w", id, err)
+	}
+
+	var replicas []entity.Replica
+	raw := record.GetString("contents")
+	if raw != "" {
+		if err := json.Unmarshal([]byte(raw), &replicas); err != nil {
+			return nil, fmt.Errorf("failed to decode structure %s", id)
+		}
+	}
+
+	return &entity.Structure{
+		Id:       record.Id,
+		RecordID: record.GetString("record"),
+		Version:  record.GetInt("version"),
+		Replicas: replicas,
+	}, nil
+}

internal/adapter/repo/pocketbase/transcript_job_repo.go

@@ -1,189 +0,0 @@
-package pocketbase
-
-import (
-	"database/sql"
-	"errors"
-	"fmt"
-	"time"
-
-	"github.com/pocketbase/dbx"
-	"github.com/pocketbase/pocketbase/core"
-	"github.com/pocketbase/pocketbase/tools/types"
-
-	"git.vakhrushev.me/av/transcriber/internal/contract"
-	"git.vakhrushev.me/av/transcriber/internal/entity"
-
-	"git.vakhrushev.me/av/transcriber/internal/adapter/repo/pocketbase/migrations"
-
-	"git.vakhrushev.me/av/transcriber/internal/clock"
-)
-
-type TranscriptJobRepository struct {
-	app core.App
-}
-
-func NewTranscriptJobRepository(app core.App) *TranscriptJobRepository {
-	return &TranscriptJobRepository{app: app}
-}
-
-func (repo *TranscriptJobRepository) Create(job *entity.TranscribeJob) error {
-	collection, err := findCollection(repo.app, migrations.JobsCollection)
-	if err != nil {
-		return err
-	}
-
-	record := core.NewRecord(collection)
-	if job.Id != "" {
-		record.Id = job.Id
-	}
-	applyToRecord(record, job)
-
-	if err := repo.app.Save(record); err != nil {
-		return fmt.Errorf("failed to insert transcribe job: %w", err)
-	}
-
-	job.Id = record.Id
-	job.CreatedAt = record.GetDateTime("created").Time()
-	job.UpdatedAt = record.GetDateTime("updated").Time()
-
-	return nil
-}
-
-// Save сохраняет задачу, захват которой держит holder. Проверка и запись идут
-// одной транзакцией: шаг, потерявший задачу за время работы, получает
-// LostAcquisitionError и результата не пишет.
-func (repo *TranscriptJobRepository) Save(job *entity.TranscribeJob, holder string) error {
-	err := repo.app.RunInTransaction(func(txApp core.App) error {
-		record, err := txApp.FindRecordById(migrations.JobsCollection, job.Id)
-		if err != nil {
-			return fmt.Errorf("failed to find transcribe job: %w", err)
-		}
-
-		if holder != "" && record.GetString("acquisition_id") != holder {
-			return &contract.LostAcquisitionError{JobID: job.Id}
-		}
-
-		// Кладём только то, чем распоряжается конвейер: правку владельца в
-		// панели снимок шага стирать не должен.
-		applyOwnedByPipeline(record, job)
-
-		if err := txApp.Save(record); err != nil {
-			return fmt.Errorf("failed to update transcribe job: %w", err)
-		}
-
-		job.UpdatedAt = record.GetDateTime("updated").Time()
-		return nil
-	})
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-// GetByID отдаёт задачу, только если её владелец — ownerID.
-//
-// Чужая задача, задача без владельца и несуществующая дают одну и ту же ошибку:
-// по разнице ответов иначе перебирается список заведённых задач, а
-// идентификатор задачи и есть то, что разграничение прячет.
-//
-// Пустой ownerID отсекается **до** чтения и не совпадает ни с чем: иначе
-// вызывающий без учётной записи получил бы ровно множество задач без владельца,
-// то есть все записи бота.
-//
-// Владелец сверяется тем же чтением, каким берётся состояние, а не отдельным
-// запросом: между двумя чтениями задача успевает измениться, и ответ перестаёт
-// быть функцией от того, что с ней произошло.
-func (repo *TranscriptJobRepository) GetByID(id, ownerID string) (*entity.TranscribeJob, error) {
-	if ownerID == "" {
-		return nil, &contract.JobNotFoundError{Message: "job not found"}
-	}
-
-	record, err := repo.app.FindRecordById(migrations.JobsCollection, id)
-	if err != nil {
-		// «Такой записи нет» переводится в доменную ошибку **здесь**, у
-		// источника, как велит конвенция об ошибках. Иначе три исхода, которые
-		// разграничение обязано сделать неразличимыми, разъезжаются: чужая и
-		// ничья задачи дают доменную ошибку, а несуществующая — отказ базы,
-		// неотличимый от настоящей аварии хранилища. Держалась бы эта
-		// неразличимость только тем, что транспорт кладёт в `404` любую ошибку,
-		// — то есть ровно тем расхождением, которое конвенция велит закрыть.
-		if errors.Is(err, sql.ErrNoRows) {
-			return nil, &contract.JobNotFoundError{Message: "job not found"}
-		}
-		return nil, fmt.Errorf("failed to get transcribe job: %w", err)
-	}
-
-	if record.GetString("owner") != ownerID {
-		return nil, &contract.JobNotFoundError{Message: "job not found"}
-	}
-
-	return recordToJob(record), nil
-}
-
-// Колонки, которые читает захват. Список нужен запросу дословно: `RETURNING *`
-// отдал бы и порядок, зависящий от схемы.
-const acquireColumns = `id, state, owner, source, file, error_text, acquisition_id, ` +
-	`acquire_time, delay_time, attempts, recognition_op_id, transcription_text, ` +
-	`tg_chat_id, tg_reply_message_id, created, updated`
-
-// FindAndAcquire забирает задачу одним неделимым шагом: выбор подходящей и
-// пометка её захваченной идут вместе, и захваченная возвращается тем же
-// запросом. Двум вызывающим, пришедшим за одним состоянием, запись достаётся
-// одному — на этом стоит инвариант «Принятая запись не теряется молча».
-//
-// Запрос идёт сырым, мимо записей коллекции: `app.DB()` направляет всё, кроме
-// выборок, в пул с единственным соединением, и захваты выстраиваются в очередь.
-// Хуки коллекции на нём не срабатывают, поэтому время изменения проставляет сам
-// запрос.
-//
-// Все времена кладутся и сравниваются тем же видом, каким хранилище пишет свои
-// `created`/`updated`: сравнение строк побайтово, и вид, разошедшийся хоть
-// разделителем, обратил бы условие срока в постоянную истину или постоянную
-// ложь — молча.
-func (repo *TranscriptJobRepository) FindAndAcquire(state, acquisitionId string, rottingTime time.Time) (*entity.TranscribeJob, error) {
-	// Метка времени берётся единой точкой, а не `types.NowDateTime()`: обёртка
-	// хранилища читает часы сама, и запрет линтера её не видит — новая метка в
-	// этом запросе обошла бы единую точку молча.
-	now, err := types.ParseDateTime(clock.Now())
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse current time: %w", err)
-	}
-
-	query := repo.app.DB().NewQuery(`
-		UPDATE {{` + migrations.JobsCollection + `}}
-		   SET acquisition_id = {:acquisition_id},
-		       acquire_time = {:now},
-		       attempts = attempts + 1,
-		       updated = {:now}
-		 WHERE id = (
-		       SELECT id FROM {{` + migrations.JobsCollection + `}}
-		        WHERE state = {:state}
-		          AND (delay_time = '' OR delay_time IS NULL OR delay_time < {:now})
-		          AND (acquisition_id = '' OR acquisition_id IS NULL OR acquire_time < {:rotting})
-		        ORDER BY created, id
-		        LIMIT 1
-		 )
-		RETURNING ` + acquireColumns)
-
-	rotting, err := types.ParseDateTime(rottingTime)
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse rotting time: %w", err)
-	}
-
-	query.Bind(dbx.Params{
-		"acquisition_id": acquisitionId,
-		"now":            now.String(),
-		"state":          state,
-		"rotting":        rotting.String(),
-	})
-
-	var row acquiredRow
-	if err := query.One(&row); err != nil {
-		if errors.Is(err, sql.ErrNoRows) {
-			return nil, &contract.JobNotFoundError{State: state, Message: "appropriate job not found"}
-		}
-		return nil, fmt.Errorf("failed to acquire job with state %s: %w", state, err)
-	}
-
-	return row.toJob(), nil
-}

internal/adapter/repo/pocketbase/transcript_job_repo_test.go

@@ -1,425 +0,0 @@
-package pocketbase
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/pocketbase/pocketbase/apis"
-	"github.com/pocketbase/pocketbase/core"
-	"github.com/pocketbase/pocketbase/tools/types"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"git.vakhrushev.me/av/transcriber/internal/contract"
-	"git.vakhrushev.me/av/transcriber/internal/entity"
-
-	"git.vakhrushev.me/av/transcriber/internal/adapter/repo/pocketbase/migrations"
-)
-
-// newTestApp поднимает хранилище на пустом каталоге и накатывает схему — тем же
-// путём, каким это делает сервис при старте.
-func newTestApp(t *testing.T) core.App {
-	t.Helper()
-
-	app, err := New(t.TempDir())
-	require.NoError(t, err)
-	t.Cleanup(func() {
-		if err := app.ResetBootstrapState(); err != nil {
-			t.Logf("не удалось закрыть хранилище: %v", err)
-		}
-	})
-
-	return app
-}
-
-// newFile заводит запись о файле: ссылка на неё у задачи обязательна схемой.
-func newFile(t *testing.T, app core.App) *entity.File {
-	t.Helper()
-
-	repo := NewFileRepository(app)
-	work, err := repo.Stage(".mp3", strings.NewReader("запись"))
-	require.NoError(t, err)
-	defer func() { require.NoError(t, work.Close()) }()
-
-	file, err := repo.CreateLocal("sample.mp3", work, "")
-	require.NoError(t, err)
-	return file
-}
-
-func newJob(t *testing.T, repo *TranscriptJobRepository, state string) *entity.TranscribeJob {
-	t.Helper()
-
-	file := newFile(t, repo.app)
-	job := &entity.TranscribeJob{State: state, Source: entity.SourceApi, FileID: &file.Id}
-	require.NoError(t, repo.Create(job))
-	return job
-}
-
-// Захват неделим: выбор подходящей задачи и пометка её захваченной идут вместе.
-// Двум вызывающим, пришедшим за одним состоянием разом, запись достаётся
-// одному — на этом стоит инвариант «Принятая запись не теряется молча».
-func TestFindAndAcquire_OnlyOneOfThreeGetsTheJob(t *testing.T) {
-	app := newTestApp(t)
-	repo := NewTranscriptJobRepository(app)
-
-	job := newJob(t, repo, entity.StateCreated)
-
-	const racers = 3
-
-	var (
-		wg       sync.WaitGroup
-		mu       sync.Mutex
-		got      []*entity.TranscribeJob
-		notFound int
-	)
-
-	start := make(chan struct{})
-	for i := 0; i < racers; i++ {
-		wg.Add(1)
-		go func(n int) {
-			defer wg.Done()
-			<-start
-
-			acquired, err := repo.FindAndAcquire(entity.StateCreated, "holder", time.Now().Add(-time.Hour))
-
-			mu.Lock()
-			defer mu.Unlock()
-			if err != nil {
-				var missing *contract.JobNotFoundError
-				if assert.ErrorAs(t, err, &missing) {
-					notFound++
-				}
-				return
-			}
-			got = append(got, acquired)
-		}(i)
-	}
-
-	close(start)
-	wg.Wait()
-
-	require.Len(t, got, 1, "запись получает ровно один из трёх захватов")
-	assert.Equal(t, job.Id, got[0].Id)
-	assert.Equal(t, racers-1, notFound, "остальные получают признак «работы нет»")
-}
-
-// Захваченная задача второй раз не выдаётся, пока срок захвата не истёк.
-func TestFindAndAcquire_AcquiredJobIsNotHandedOutAgain(t *testing.T) {
-	app := newTestApp(t)
-	repo := NewTranscriptJobRepository(app)
-
-	newJob(t, repo, entity.StateCreated)
-
-	first, err := repo.FindAndAcquire(entity.StateCreated, "first", time.Now().Add(-time.Hour))
-	require.NoError(t, err)
-	require.NotNil(t, first)
-
-	_, err = repo.FindAndAcquire(entity.StateCreated, "second", time.Now().Add(-time.Hour))
-
-	var missing *contract.JobNotFoundError
-	assert.ErrorAs(t, err, &missing, "захваченная задача второму не выдаётся")
-}
-
-// Захват протухает, и задача достаётся снова. Время захвата кладётся **не**
-// нашим кодом, а тем же путём, что и `created`: проверка, кладущая его своим
-// форматом, была бы зелена и тогда, когда сравнение вида сломано.
-func TestFindAndAcquire_RottenAcquisitionIsHandedOutAgain(t *testing.T) {
-	app := newTestApp(t)
-	repo := NewTranscriptJobRepository(app)
-
-	job := newJob(t, repo, entity.StateCreated)
-
-	_, err := repo.FindAndAcquire(entity.StateCreated, "first", time.Now().Add(-time.Hour))
-	require.NoError(t, err)
-
-	// Задним числом — записью коллекции, то есть тем же слоем, который пишет
-	// собственные времена хранилища.
-	record, err := app.FindRecordById(migrations.JobsCollection, job.Id)
-	require.NoError(t, err)
-	record.Set("acquire_time", types.NowDateTime().Add(-2*time.Hour))
-	require.NoError(t, app.Save(record))
-
-	again, err := repo.FindAndAcquire(entity.StateCreated, "second", time.Now().Add(-time.Hour))
-	require.NoError(t, err, "протухший захват не мешает выдать задачу следующему")
-	assert.Equal(t, job.Id, again.Id)
-}
-
-// Пауза держит задачу от выдачи, пока не кончится.
-func TestFindAndAcquire_DelayedJobIsNotHandedOut(t *testing.T) {
-	app := newTestApp(t)
-	repo := NewTranscriptJobRepository(app)
-
-	job := newJob(t, repo, entity.StateCreated)
-
-	delay := time.Now().Add(time.Hour)
-	job.DelayTime = &delay
-	require.NoError(t, repo.Save(job, ""))
-
-	_, err := repo.FindAndAcquire(entity.StateCreated, "holder", time.Now().Add(-time.Hour))
-
-	var missing *contract.JobNotFoundError
-	assert.ErrorAs(t, err, &missing, "задача не выдаётся, пока пауза не кончилась")
-}
-
-// Число попыток растёт при каждом захвате: только так попытка засчитывается и
-// задаче, брошенной вместе с процессом.
-func TestFindAndAcquire_AttemptsGrowOnEveryAcquisition(t *testing.T) {
-	app := newTestApp(t)
-	repo := NewTranscriptJobRepository(app)
-
-	newJob(t, repo, entity.StateCreated)
-
-	for expected := 1; expected <= 3; expected++ {
-		acquired, err := repo.FindAndAcquire(entity.StateCreated, "holder", time.Now().Add(time.Hour))
-		require.NoError(t, err)
-		assert.Equal(t, expected, acquired.Attempts)
-	}
-}
-
-// Захват отдаёт задачу целиком, а не только её ключ: сырой запрос идёт мимо
-// записей коллекции, и расхождение перечня колонок иначе проявилось бы как
-// потерянное поле.
-func TestFindAndAcquire_ReturnsWholeJob(t *testing.T) {
-	app := newTestApp(t)
-	repo := NewTranscriptJobRepository(app)
-
-	chatId := int64(4242)
-	replyId := 17
-	opId := "operation-id"
-	text := "расшифровка"
-
-	file := newFile(t, app)
-
-	job := &entity.TranscribeJob{
-		State:             entity.StateTranscribe,
-		Source:            entity.SourceTelegram,
-		FileID:            &file.Id,
-		TgChatId:          &chatId,
-		TgReplyMessageId:  &replyId,
-		RecognitionOpID:   &opId,
-		TranscriptionText: &text,
-	}
-	require.NoError(t, repo.Create(job))
-
-	acquired, err := repo.FindAndAcquire(entity.StateTranscribe, "holder", time.Now().Add(-time.Hour))
-	require.NoError(t, err)
-
-	assert.Equal(t, job.Id, acquired.Id)
-	assert.Equal(t, entity.StateTranscribe, acquired.State)
-	assert.Equal(t, entity.SourceTelegram, acquired.Source)
-	require.NotNil(t, acquired.TgChatId)
-	assert.Equal(t, chatId, *acquired.TgChatId)
-	require.NotNil(t, acquired.TgReplyMessageId)
-	assert.Equal(t, replyId, *acquired.TgReplyMessageId)
-	require.NotNil(t, acquired.RecognitionOpID)
-	assert.Equal(t, opId, *acquired.RecognitionOpID)
-	require.NotNil(t, acquired.TranscriptionText)
-	assert.Equal(t, text, *acquired.TranscriptionText)
-	assert.False(t, acquired.CreatedAt.IsZero(), "время заведения доехало")
-}
-
-// Шаг, потерявший захват за время работы, результата не пишет: иначе два
-// воркера пишут в одну задачу по очереди, а отправитель получает два ответа.
-func TestSave_RefusesWriteFromLostAcquisition(t *testing.T) {
-	app := newTestApp(t)
-	repo := NewTranscriptJobRepository(app)
-
-	newJob(t, repo, entity.StateCreated)
-
-	mine, err := repo.FindAndAcquire(entity.StateCreated, "mine", time.Now().Add(-time.Hour))
-	require.NoError(t, err)
-
-	// Задача досталась другому, пока шаг работал.
-	record, err := app.FindRecordById(migrations.JobsCollection, mine.Id)
-	require.NoError(t, err)
-	record.Set("acquisition_id", "someone-else")
-	require.NoError(t, app.Save(record))
-
-	mine.MoveToState(entity.StateConverted)
-	err = repo.Save(mine, "mine")
-
-	var lost *contract.LostAcquisitionError
-	require.ErrorAs(t, err, &lost)
-
-	// И состояние не поехало.
-	after, err := readJobByID(t, app, mine.Id)
-	require.NoError(t, err)
-	assert.Equal(t, entity.StateCreated, after.State)
-}
-
-// Пустой держатель значит «задача не захватывалась» — так её сохраняет приём.
-func TestSave_WithoutHolderWritesAnyway(t *testing.T) {
-	app := newTestApp(t)
-	repo := NewTranscriptJobRepository(app)
-
-	job := newJob(t, repo, entity.StateCreated)
-	job.MoveToState(entity.StateConverted)
-
-	require.NoError(t, repo.Save(job, ""))
-
-	after, err := readJobByID(t, app, job.Id)
-	require.NoError(t, err)
-	assert.Equal(t, entity.StateConverted, after.State)
-}
-
-// Правка состояния **запросом** — то есть из панели — чистит служебные поля
-// прошлого состояния: те же, что чистит переход из кода. Иначе владелец,
-// вернувший мёртвую задачу в работу, получил бы задачу, которая не выдаётся
-// захвату и умирает от первого же отказа, и не узнал бы об этом.
-func TestPanelRules_StateChangeByRequestClearsAcquisition(t *testing.T) {
-	app := newTestApp(t)
-	BindPanelRules(app)
-
-	repo := NewTranscriptJobRepository(app)
-	job := newJob(t, repo, entity.StateCreated)
-
-	acquired, err := repo.FindAndAcquire(entity.StateCreated, "holder", time.Now().Add(-time.Hour))
-	require.NoError(t, err)
-	require.NotNil(t, acquired.AcquisitionID)
-
-	record, err := app.FindRecordById(migrations.JobsCollection, job.Id)
-	require.NoError(t, err)
-	record.Set("attempts", 5)
-	record.Set("state", entity.StateDead)
-	require.NoError(t, app.Save(record))
-
-	// Владелец возвращает задачу в работу правкой состояния в панели — то есть
-	// запросом к записи, а не сохранением из кода.
-	patchRecord(t, app, job.Id, `{"state":"`+entity.StateCreated+`"}`)
-
-	after, err := readJobByID(t, app, job.Id)
-	require.NoError(t, err)
-	assert.Nil(t, after.AcquisitionID, "признак захвата снят")
-	assert.Nil(t, after.AcquireTime, "время захвата снято")
-	assert.Nil(t, after.DelayTime, "пауза снята")
-	assert.Equal(t, 0, after.Attempts, "число попыток обнулено")
-
-	// И ближайший захват задачу выдаёт.
-	again, err := repo.FindAndAcquire(entity.StateCreated, "next", time.Now().Add(-time.Hour))
-	require.NoError(t, err)
-	assert.Equal(t, job.Id, again.Id)
-}
-
-// Обратная сторона того же правила, и она дороже: правила панели MUST не
-// трогать записи, которые правит сам конвейер. Модельный хук их не различал, и
-// пауза, поставленная шагом вместе со сменой состояния, стиралась тем же
-// сохранением, а число попыток мёртвой задачи приходило владельцу нулём.
-func TestPanelRules_DoNotTouchPipelineWrites(t *testing.T) {
-	app := newTestApp(t)
-	BindPanelRules(app)
-
-	repo := NewTranscriptJobRepository(app)
-	job := newJob(t, repo, entity.StateConverted)
-
-	acquired, err := repo.FindAndAcquire(entity.StateConverted, "holder", time.Now().Add(-time.Hour))
-	require.NoError(t, err)
-
-	// Шаг ставит задержку опроса вместе со сменой состояния.
-	delay := time.Now().Add(10 * time.Second)
-	acquired.MoveToStateAndDelay(entity.StateTranscribe, &delay)
-	require.NoError(t, repo.Save(acquired, "holder"))
-
-	after, err := readJobByID(t, app, job.Id)
-	require.NoError(t, err)
-	require.NotNil(t, after.DelayTime, "задержка, поставленная шагом, пережила сохранение")
-
-	// Переход в «мертва» хранит число попыток намеренно: по нему владелец видит,
-	// сколько раз мы пробовали.
-	after.Attempts = 6
-	after.Die("attempts exhausted: 6")
-	require.NoError(t, repo.Save(after, ""))
-
-	dead, err := readJobByID(t, app, job.Id)
-	require.NoError(t, err)
-	assert.Equal(t, entity.StateDead, dead.State)
-	assert.Equal(t, 6, dead.Attempts, "число попыток мёртвой задачи сохранено")
-}
-
-// patchRecord правит запись тем же путём, каким её правит панель: запросом к
-// API от имени владельца.
-func patchRecord(t *testing.T, app core.App, recordID, body string) {
-	t.Helper()
-
-	superusers, err := app.FindCollectionByNameOrId(core.CollectionNameSuperusers)
-	require.NoError(t, err)
-
-	owner := core.NewRecord(superusers)
-	owner.Set("email", "owner@example.com")
-	owner.Set("password", "ownerpassword123")
-	require.NoError(t, app.Save(owner))
-
-	token, err := owner.NewStaticAuthToken(time.Hour)
-	require.NoError(t, err)
-
-	router, err := apis.NewRouter(app)
-	require.NoError(t, err)
-	mux, err := router.BuildMux()
-	require.NoError(t, err)
-
-	req := httptest.NewRequest(
-		http.MethodPatch,
-		"/api/collections/"+migrations.JobsCollection+"/records/"+recordID,
-		strings.NewReader(body),
-	)
-	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("Authorization", token)
-
-	w := httptest.NewRecorder()
-	mux.ServeHTTP(w, req)
-	require.Equal(t, http.StatusOK, w.Code, "правка записи владельцем: %s", w.Body.String())
-}
-
-// Правка владельца в панели переживает сохранение шага. Шаг держит задачу
-// снимком с момента захвата и до своего сохранения — до восьми часов, — и
-// безусловная запись снимка стёрла бы правку молча: ни строки в журнале, ни
-// отказа в панели.
-func TestSave_KeepsOwnerEditMadeWhileStepHeldTheJob(t *testing.T) {
-	app := newTestApp(t)
-	BindPanelRules(app)
-
-	repo := NewTranscriptJobRepository(app)
-
-	file := newFile(t, app)
-	chatId := int64(111)
-	job := &entity.TranscribeJob{
-		State:    entity.StateCreated,
-		Source:   entity.SourceTelegram,
-		FileID:   &file.Id,
-		TgChatId: &chatId,
-	}
-	require.NoError(t, repo.Create(job))
-
-	// Шаг захватил задачу и работает.
-	acquired, err := repo.FindAndAcquire(entity.StateCreated, "holder", time.Now().Add(-time.Hour))
-	require.NoError(t, err)
-
-	// Владелец правит в панели поле, которого конвейер не касается.
-	patchRecord(t, app, job.Id, `{"tg_chat_id":999999}`)
-
-	// Шаг доработал и сохраняет свой снимок.
-	acquired.MoveToState(entity.StateConverted)
-	require.NoError(t, repo.Save(acquired, "holder"))
-
-	after, err := readJobByID(t, app, job.Id)
-	require.NoError(t, err)
-	assert.Equal(t, entity.StateConverted, after.State, "шаг свой результат записал")
-	require.NotNil(t, after.TgChatId)
-	assert.Equal(t, int64(999999), *after.TgChatId, "правка владельца пережила сохранение шага")
-}
-
-// readJobByID читает задачу мимо сужения владельцем: проверки хранилища смотрят
-// задачи без владельца, а читающий метод их не отдаёт никому. Отображение при
-// этом то же самое — сверяется именно оно.
-func readJobByID(t *testing.T, app core.App, id string) (*entity.TranscribeJob, error) {
-	t.Helper()
-
-	record, err := app.FindRecordById(migrations.JobsCollection, id)
-	if err != nil {
-		return nil, err
-	}
-	return recordToJob(record), nil
-}

internal/archrules/arch_test.go

@@ -174,186 +174,211 @@ func TestОшибкаНеУзнаётсяПоТексту(t *testing.T) {
 	}
 }
 
-// Колонки очереди правятся в четырёх местах пакета хранилища плюс шаг схемы, и
-// компилятор видит два из них (инвариант CLAUDE.md, «Инварианты», major).
-// Колонка, забытая в паре `acquireColumns`/`acquiredRow`, приезжает из захвата
-// нулевой, и первый же `Save` пишет этот ноль поверх сохранённого значения —
-// поле теряется только у задачи, попавшей к воркеру.
+// Перечень колонок аудиозаписи компилятор не видит: их пишет `applyOwnedByPipeline`,
+// читает `recordToAudioRecord`, и заводит шаг схемы. Колонка, забытая в паре
+// «пишем — читаем», теряется молча: запись, прочитанная не тем путём, приезжает
+// с нулевым полем, и первое же сохранение пишет этот ноль поверх значения.
 //
-// Правила ниже закрывают все четыре места плюс шаг схемы: перечень запроса,
-// структуру захвата, запись коллекции (`applyToRecord`/`recordToJob`) и перенос
-// поля в задачу (`toJob`). Литерал колонки ищется **в телах** нужных функций, а
-// не в файле: файл держит и структуру с тегами `db:"…"`, и по ней условие
-// выполнялось бы само собой.
+// Мест стало **два** вместо прежних четырёх: захват больше не перечисляет
+// колонки поимённо, а возвращает идентификатор и признак своего захвата. Правила
+// ниже держат оставшуюся пару плюс шаг схемы.
 const (
 	repoPkg        = "internal/adapter/repo/pocketbase"
-	acquireFile    = repoPkg + "/transcript_job_repo.go"
-	mappingFile    = repoPkg + "/job_mapping.go"
+	mappingFile    = repoPkg + "/record_mapping.go"
 	migrationsPath = repoPkg + "/migrations"
+	stageFile      = "internal/entity/stage.go"
+	stateFile      = "internal/entity/audio_record.go"
+	serviceFile    = "internal/service/transcribe.go"
 )
 
-// Колонки, которые заводит и заполняет само хранилище: перечня запроса они
-// касаются, а нашего кода — нет.
+// Колонки, которые заводит и заполняет само хранилище: нашего кода они не
+// касаются.
 var storageOwned = map[string]bool{"id": true, "created": true, "updated": true}
 
-func TestПереченьЗахватаСовпадаетСоСтруктурой(t *testing.T) {
-	query := acquireColumnNames(t)
-	row := rowColumnNames(t)
+func TestКолонкиЗаписиПишутсяИЧитаются(t *testing.T) {
+	written := writtenColumns(t)
+	read := readColumns(t)
 
-	for _, col := range query {
-		if !row[col] {
+	for col := range written {
+		if storageOwned[col] {
+			continue
+		}
+		if !read[col] {
 			t.Errorf(
-				"колонка %q есть в acquireColumns, но не в acquiredRow: из захвата "+
-					"она приедет нулевой, и первый Save затрёт сохранённое значение",
+				"колонку %q пишет отображение записи, но recordToAudioRecord её не "+
+					"читает: запись приедет из хранилища без этого поля",
 				col,
 			)
 		}
-		delete(row, col)
 	}
-	for col := range row {
-		t.Errorf(
-			"колонка %q есть в acquiredRow, но не в acquireColumns: запрос её не "+
-				"читает, и поле остаётся нулевым",
-			col,
-		)
+	for col := range read {
+		if storageOwned[col] {
+			continue
+		}
+		if !written[col] {
+			t.Errorf(
+				"колонку %q читает recordToAudioRecord, но её не пишет ни "+
+					"applyOwnedByPipeline, ни applyToRecord: поле не сохранится",
+				col,
+			)
+		}
 	}
 }
 
-func TestКолонкиЗахватаЗаведеныШагомСхемы(t *testing.T) {
+func TestКолонкиЗаписиЗаведеныШагомСхемы(t *testing.T) {
 	declared := schemaFieldNames(t)
-	for _, col := range acquireColumnNames(t) {
-		if col == "id" {
-			continue // ключ заводит само хранилище, шаг схемы его не объявляет
+	for col := range writtenColumns(t) {
+		if storageOwned[col] {
+			continue
 		}
 		if !declared[col] {
 			t.Errorf(
-				"колонка %q читается захватом, но ни один шаг схемы её не заводит: "+
-					"запрос отвалится на живой базе",
+				"колонка %q пишется отображением записи, но ни один шаг схемы её не "+
+					"заводит: сохранение отвалится на живой базе",
 				col,
 			)
 		}
 	}
 }
 
-// Четвёртое место — путь через запись коллекции: `applyToRecord` пишет колонку,
-// `recordToJob` читает. Ищется литерал **в телах этих функций**, а не в файле:
-// в файле лежит и структура захвата со своими тегами `db:"…"`, и по ней условие
-// выполнялось бы само собой — правило было бы зелёным всегда.
-func TestКолонкиЗахватаЧитаютсяИЧерезЗапись(t *testing.T) {
-	write := funcBody(t, mappingFile, "func applyOwnedByPipeline(") +
+// Рубеж объявлен одним дескриптором, но шаг под него пишется в другом месте, и
+// связь между ними компилятор не видит. Рубеж, оставшийся без шага, из работы не
+// выходит: воркер его захватит, шага не найдёт и остановит запись — а рубеж,
+// забытый в дескрипторе, не выдаётся захвату вовсе, и пустой прогон по
+// инварианту проекта не пишется в журнал и не считается в метрику.
+func TestУКаждогоРабочегоРубежаЕстьШаг(t *testing.T) {
+	body := funcBody(t, serviceFile, "func (s *TranscribeService) stepFor(")
+	for _, stage := range workingStageIdents(t) {
+		if !strings.Contains(body, "entity."+stage) {
+			t.Errorf(
+				"рубеж entity.%s объявлен рабочим в дескрипторе, но шага под него нет "+
+					"в таблице stepFor: запись с этим рубежом остановится, не начав работы",
+				stage,
+			)
+		}
+	}
+}
+
+// Обратное направление того же правила: шаг, написанный под рубеж, которого в
+// дескрипторе нет, недостижим — захват такую запись не выдаст никогда.
+func TestШагиОбъявленыРубежамиДескриптора(t *testing.T) {
+	body := funcBody(t, serviceFile, "func (s *TranscribeService) stepFor(")
+	declared := map[string]bool{}
+	for _, stage := range stageIdents(t) {
+		declared[stage] = true
+	}
+
+	re := regexp.MustCompile(`case entity\.(\w+):`)
+	for _, m := range re.FindAllStringSubmatch(body, -1) {
+		if !declared[m[1]] {
+			t.Errorf(
+				"в таблице stepFor есть ветка для entity.%s, но такого рубежа нет в "+
+					"дескрипторе: запись с этим рубежом захвату не выдаётся",
+				m[1],
+			)
+		}
+	}
+}
+
+// writtenColumns — колонки, которые пишет отображение записи в хранилище.
+func writtenColumns(t *testing.T) map[string]bool {
+	t.Helper()
+	body := funcBody(t, mappingFile, "func applyOwnedByPipeline(") +
 		funcBody(t, mappingFile, "func applyToRecord(")
-	read := funcBody(t, mappingFile, "func recordToJob(")
-
-	for _, col := range acquireColumnNames(t) {
-		if storageOwned[col] {
-			continue // эти колонки заводит и заполняет само хранилище
-		}
-		if !strings.Contains(write, `"`+col+`"`) {
-			t.Errorf(
-				"колонку %q читает захват, но её не пишет ни applyOwnedByPipeline, "+
-					"ни applyToRecord: путь через запись коллекции её потеряет",
-				col,
-			)
-		}
-		if !strings.Contains(read, `"`+col+`"`) {
-			t.Errorf(
-				"колонку %q читает захват, но recordToJob её не читает: задача, "+
-					"прочитанная не захватом, приедет без этого поля",
-				col,
-			)
-		}
-	}
-}
-
-// Пятое условие того же инварианта: колонка, доехавшая до структуры захвата,
-// обязана попасть в задачу. `toJob` обращается к **полям**, а не к литералам,
-// поэтому сверяются имена полей, а не имена колонок: поле, забытое здесь,
-// приезжает из захвата прочитанным и теряется на последнем шаге.
-func TestПоляСтруктурыЗахватаДоезжаютДоЗадачи(t *testing.T) {
-	body := funcBody(t, mappingFile, "func (r *acquiredRow) toJob()")
-	for _, field := range rowFieldNames(t) {
-		if !strings.Contains(body, "r."+field) {
-			t.Errorf(
-				"поле %s структуры захвата не читается в toJob: колонка приедет из "+
-					"запроса, но в задачу не попадёт",
-				field,
-			)
-		}
-	}
-}
-
-// --- Чтение исходников ------------------------------------------------------
-
-// acquireColumnNames достаёт имена колонок из константы `acquireColumns`. Она
-// склеена из строковых литералов, поэтому берётся текстом, а не разбором типов:
-// значение константы известно на месте.
-func acquireColumnNames(t *testing.T) []string {
-	t.Helper()
-	body := readFile(t, acquireFile)
-	const marker = "const acquireColumns = "
-	start := strings.Index(body, marker)
-	if start < 0 {
-		t.Fatalf("в %s нет константы acquireColumns: правило потеряло предмет", acquireFile)
-	}
-	tail := body[start+len(marker):]
-	end := strings.Index(tail, "`\n")
-	if end < 0 {
-		t.Fatalf("не нашёл конец константы acquireColumns в %s", acquireFile)
-	}
-	var cols []string
-	for _, chunk := range strings.Split(strings.NewReplacer("`", "", "+", "", "\n", "", "\t", "").Replace(tail[:end]), ",") {
-		if col := strings.TrimSpace(chunk); col != "" {
-			cols = append(cols, col)
-		}
-	}
-	if len(cols) == 0 {
-		t.Fatalf("перечень acquireColumns прочитан пустым: правило потеряло предмет")
-	}
-	return cols
-}
-
-// rowColumnNames достаёт колонки из тегов `db:"…"` структуры `acquiredRow`.
-func rowColumnNames(t *testing.T) map[string]bool {
-	t.Helper()
 	out := map[string]bool{}
-	for _, m := range regexp.MustCompile("`db:\"([^\"]+)\"`").FindAllStringSubmatch(rowStruct(t), -1) {
+	for _, m := range regexp.MustCompile(`record\.Set\("([^"]+)"`).FindAllStringSubmatch(body, -1) {
 		out[m[1]] = true
 	}
 	if len(out) == 0 {
-		t.Fatalf("у acquiredRow не прочитан ни один тег db: правило потеряло предмет")
+		t.Fatalf("отображение записи не пишет ни одной колонки: правило потеряло предмет")
 	}
 	return out
 }
 
-// rowFieldNames достаёт имена полей структуры `acquiredRow` — те, к которым
-// обращается `toJob`.
-func rowFieldNames(t *testing.T) []string {
+// readColumns — колонки, которые читает обратное отображение.
+func readColumns(t *testing.T) map[string]bool {
 	t.Helper()
-	var out []string
-	for _, m := range regexp.MustCompile(`(?m)^\t([A-Z]\w*)\s`).FindAllStringSubmatch(rowStruct(t), -1) {
-		out = append(out, m[1])
+	body := funcBody(t, mappingFile, "func recordToAudioRecord(")
+	out := map[string]bool{}
+	for _, m := range regexp.MustCompile(`\.Get\w+\("([^"]+)"\)`).FindAllStringSubmatch(body, -1) {
+		out[m[1]] = true
 	}
 	if len(out) == 0 {
-		t.Fatalf("у acquiredRow не прочитано ни одно поле: правило потеряло предмет")
+		t.Fatalf("recordToAudioRecord не читает ни одной колонки: правило потеряло предмет")
 	}
 	return out
 }
 
-// rowStruct — текст объявления структуры `acquiredRow`.
-func rowStruct(t *testing.T) string {
+// stageIdents — имена констант рубежей, перечисленных дескриптором.
+func stageIdents(t *testing.T) []string {
 	t.Helper()
-	body := readFile(t, mappingFile)
-	start := strings.Index(body, "type acquiredRow struct {")
+	out, _ := stageDescriptor(t)
+	return out
+}
+
+// workingStageIdents — то же, но без конечного рубежа: из него запись в работу
+// не берут.
+func workingStageIdents(t *testing.T) []string {
+	t.Helper()
+	_, working := stageDescriptor(t)
+	return working
+}
+
+func stageDescriptor(t *testing.T) (all []string, working []string) {
+	t.Helper()
+	body := readFile(t, stageFile)
+	const marker = "var stages = []Stage{"
+	start := strings.Index(body, marker)
 	if start < 0 {
-		t.Fatalf("в %s нет структуры acquiredRow: правило потеряло предмет", mappingFile)
+		t.Fatalf("в %s нет дескриптора рубежей: правило потеряло предмет", stageFile)
 	}
 	end := strings.Index(body[start:], "\n}")
 	if end < 0 {
-		t.Fatalf("не нашёл конец структуры acquiredRow в %s", mappingFile)
+		t.Fatalf("не нашёл конец дескриптора рубежей в %s", stageFile)
 	}
-	return body[start : start+end]
+
+	declared := declaredStates(t)
+	re := regexp.MustCompile(`\{Name: (\w+)[^}]*\}`)
+	for _, m := range re.FindAllStringSubmatch(body[start:start+end], -1) {
+		if !declared[m[1]] {
+			t.Errorf(
+				"дескриптор называет рубеж %s, которого нет среди объявленных состояний "+
+					"в %s: перечень схемы разошёлся бы с ним молча",
+				m[1], stateFile,
+			)
+			continue
+		}
+		all = append(all, m[1])
+		if !strings.Contains(m[0], "Terminal: true") {
+			working = append(working, m[1])
+		}
+	}
+
+	if len(all) == 0 {
+		t.Fatalf("дескриптор рубежей прочитан пустым: правило потеряло предмет")
+	}
+	if len(working) == 0 {
+		t.Fatalf("в дескрипторе нет ни одного рабочего рубежа: правило потеряло предмет")
+	}
+	return all, working
 }
 
+// declaredStates — константы рубежей, объявленные доменом.
+func declaredStates(t *testing.T) map[string]bool {
+	t.Helper()
+	out := map[string]bool{}
+	re := regexp.MustCompile(`(?m)^\t(State\w+)\s*=\s*"`)
+	for _, m := range re.FindAllStringSubmatch(readFile(t, stateFile), -1) {
+		out[m[1]] = true
+	}
+	if len(out) == 0 {
+		t.Fatalf("в %s не объявлено ни одного рубежа: правило потеряло предмет", stateFile)
+	}
+	return out
+}
+
+// --- Чтение исходников ------------------------------------------------------
+
 // funcBody — текст тела функции от её заголовка до закрывающей скобки в первой
 // позиции строки. Пропавший заголовок — отказ, а не пустое тело: правило,
 // потерявшее предмет, обязано краснеть, а не зеленеть.

internal/config/config.go

@@ -7,18 +7,59 @@ import (
 	"os"
 	"sort"
 	"strings"
+	"time"
 
 	"github.com/BurntSushi/toml"
+
+	"git.vakhrushev.me/av/transcriber/internal/entity"
 )
 
 type Config struct {
 	Server   ServerConfig   `toml:"server"`
 	Storage  StorageConfig  `toml:"storage"`
+	Pipeline PipelineConfig `toml:"pipeline"`
 	Yandex   YandexConfig   `toml:"yandex"`
 	Telegram TelegramConfig `toml:"telegram"`
 	Auth     AuthConfig     `toml:"auth"`
 }
 
+// PipelineConfig — настройки конвейера расшифровки.
+type PipelineConfig struct {
+	// Workers — число одинаковых воркеров. Ноль — законное значение: сервис
+	// поднимается, записи принимаются и не двигаются. Это режим, а не поломка.
+	Workers int `toml:"workers"`
+	// OwnWorkLimitMinutes — предел простоя записи там, где работу делаем мы
+	// сами. Сторож ловит **зависание**, а не долгую работу: живой шаг
+	// наблюдается по самому процессу, а остановка обратима — снятие признака
+	// возвращает запись на её рубеж.
+	OwnWorkLimitMinutes int `toml:"own_work_limit_minutes"`
+	// ForeignWorkLimitMinutes — предел простоя там, где ждём чужую операцию.
+	// Сколько идёт распознавание долгой записи, никто не мерил, поэтому ошибка
+	// идёт в сторону долгого: ложная остановка хуже поздней.
+	ForeignWorkLimitMinutes int `toml:"foreign_work_limit_minutes"`
+}
+
+// StuckLimits переводит настройки в пределы простоя.
+func (c PipelineConfig) StuckLimits() entity.StuckLimits {
+	return entity.StuckLimits{
+		Own:     time.Duration(c.OwnWorkLimitMinutes) * time.Minute,
+		Foreign: time.Duration(c.ForeignWorkLimitMinutes) * time.Minute,
+	}
+}
+
+// Validate проверяет числа конвейера. Отрицательное число воркеров — ошибка
+// настройки, а не режим: ноль объявлен законным значением, и отличать его от
+// опечатки обязан старт.
+func (c PipelineConfig) Validate() error {
+	if c.Workers < 0 {
+		return errors.New("pipeline: число воркеров не может быть отрицательным")
+	}
+	if c.OwnWorkLimitMinutes <= 0 || c.ForeignWorkLimitMinutes <= 0 {
+		return errors.New("pipeline: пределы простоя задаются положительным числом минут")
+	}
+	return nil
+}
+
 type ServerConfig struct {
 	Port                 int      `toml:"port"`
 	ShutdownTimeout      int      `toml:"shutdown_timeout"`
@@ -143,6 +184,15 @@ func defaultConfig() *Config {
 		Storage: StorageConfig{
 			DataDir: "data",
 		},
+		Pipeline: PipelineConfig{
+			Workers: 3,
+			// Час на свою работу и сутки на чужую. Час меньше времени, которое
+			// многочасовая запись занимает на приведении, и это принято
+			// сознательно: сторож ловит зависание, живой шаг наблюдается по
+			// самому процессу, а остановка обратима.
+			OwnWorkLimitMinutes:     60,
+			ForeignWorkLimitMinutes: 24 * 60,
+		},
 		Yandex: YandexConfig{
 			FolderID:             "",
 			SpeechKitAPIKey:      "",

internal/config/config_test.go

@@ -6,6 +6,7 @@ import (
 	"path/filepath"
 	"strings"
 	"testing"
+	"time"
 )
 
 // Проверка входа — единственная страховка от того, чтобы сервис поднялся с
@@ -274,3 +275,71 @@ func TestLoadConfigMalformedBeforeAnyKeyHidesValue(t *testing.T) {
 		t.Fatalf("место отказа не названо, чинить нечего: %v", err)
 	}
 }
+
+// Числа конвейера приезжают из файла, а не выдумываются кодом.
+func TestLoadConfigReadsPipelineSettings(t *testing.T) {
+	path := writeConfig(t, `
+[pipeline]
+workers = 7
+own_work_limit_minutes = 90
+foreign_work_limit_minutes = 720
+
+[telegram]
+enabled = false
+`)
+
+	cfg, err := LoadConfig(path)
+	if err != nil {
+		t.Fatalf("конфиг не прочитан: %v", err)
+	}
+
+	if cfg.Pipeline.Workers != 7 {
+		t.Errorf("число воркеров не прочитано: %d", cfg.Pipeline.Workers)
+	}
+
+	limits := cfg.Pipeline.StuckLimits()
+	if limits.Own != 90*time.Minute {
+		t.Errorf("предел своей работы не прочитан: %v", limits.Own)
+	}
+	if limits.Foreign != 720*time.Minute {
+		t.Errorf("предел чужой работы не прочитан: %v", limits.Foreign)
+	}
+}
+
+// Умолчания есть у всех трёх чисел: файл без секции конвейера годен, и сервис
+// поднимается с рабочими значениями.
+func TestPipelineSettingsHaveDefaults(t *testing.T) {
+	path := writeConfig(t, "[telegram]\nenabled = false\n")
+
+	cfg, err := LoadConfig(path)
+	if err != nil {
+		t.Fatalf("конфиг не прочитан: %v", err)
+	}
+
+	if cfg.Pipeline.Workers <= 0 {
+		t.Errorf("умолчание числа воркеров негодно: %d", cfg.Pipeline.Workers)
+	}
+	if err := cfg.Pipeline.Validate(); err != nil {
+		t.Errorf("умолчания не проходят собственную проверку: %v", err)
+	}
+}
+
+// Ноль воркеров — объявленный режим, а отрицательное число и нулевой предел —
+// опечатка: подниматься с ней значит остановить всякую запись первым же
+// захватом.
+func TestPipelineValidateSeparatesModeFromTypo(t *testing.T) {
+	valid := PipelineConfig{Workers: 0, OwnWorkLimitMinutes: 60, ForeignWorkLimitMinutes: 1440}
+	if err := valid.Validate(); err != nil {
+		t.Errorf("ноль воркеров объявлен законным значением: %v", err)
+	}
+
+	for name, cfg := range map[string]PipelineConfig{
+		"отрицательное число воркеров": {Workers: -1, OwnWorkLimitMinutes: 60, ForeignWorkLimitMinutes: 1440},
+		"нулевой предел своей работы":  {Workers: 1, OwnWorkLimitMinutes: 0, ForeignWorkLimitMinutes: 1440},
+		"нулевой предел чужой работы":  {Workers: 1, OwnWorkLimitMinutes: 60, ForeignWorkLimitMinutes: 0},
+	} {
+		if err := cfg.Validate(); err == nil {
+			t.Errorf("%s принято за режим", name)
+		}
+	}
+}

internal/contract/contract.go

@@ -24,10 +24,39 @@ type AudioFileConverter interface {
 	Convert(ctx context.Context, src, dest string) error
 }
 
+// AudioRecognizer — внешний распознаватель речи.
+//
+// Заливка и отправка операции разделены: это два обращения с разной ценой
+// повтора. Повтор заливки бесплатен и кладёт объект под тем же ключом; повтор
+// отправки оплачивается наружу, и шаг обязан проверить сделанное прежде, чем
+// платить второй раз.
+//
+// Результат отдаётся **доменным** — реплики со временем, плоский текст и байты
+// ответа на хранение, — а не сырым форматом провайдера: разбор потока это
+// обязанность адаптера, и ни один шаг конвейера не знает, каким потоком и какими
+// полями провайдер отвечает.
 type AudioRecognizer interface {
-	Recognize(ctx context.Context, file io.Reader, fileName string) (operationID string, err error)
-	GetRecognitionText(ctx context.Context, operationID string) (string, error)
-	CheckRecognitionStatus(ctx context.Context, operationID string) (*entity.RecognitionResult, error)
+	// Provider — имя провайдера, под которым сохраняется попытка.
+	Provider() string
+	// Model — имя модели распознавания.
+	Model() string
+	// Upload кладёт аудио туда, откуда провайдер его прочитает, и отдаёт адрес.
+	// Повтор кладёт объект под тем же ключом и оплаты не стоит.
+	Upload(ctx context.Context, file io.Reader, objectKey string) (sourceURI string, err error)
+	// ObjectExists отвечает, лежит ли объект нужного размера. По нему шаг решает,
+	// повторять ли заливку; сверка содержимого хешем ненадёжна — признак
+	// целостности у составного объекта не равен отпечатку содержимого.
+	ObjectExists(ctx context.Context, objectKey string, size int64) (bool, error)
+	// Submit заводит операцию распознавания по адресу аудио. Оплачивается
+	// наружу.
+	Submit(ctx context.Context, sourceURI string) (operationID string, err error)
+	// CheckStatus опрашивает операцию.
+	CheckStatus(ctx context.Context, operationID string) (*entity.RecognitionResult, error)
+	// Fetch забирает готовый результат и отдаёт его доменным.
+	Fetch(ctx context.Context, operationID string) (*entity.RecognitionOutcome, error)
+	// Parse строит доменный результат из **сохранённого** ответа провайдера, не
+	// обращаясь к нему. По нему архив пересчитывается без единого рубля.
+	Parse(raw []byte) (*entity.RecognitionOutcome, error)
 }
 
 type TelegramMessageSender interface {

internal/contract/repository.go

@@ -2,7 +2,6 @@ package contract
 
 import (
 	"io"
-	"time"
 
 	"git.vakhrushev.me/av/transcriber/internal/entity"
 )
@@ -23,6 +22,14 @@ type WorkFile interface {
 	Close() error
 }
 
+// FileMeta — что известно о копии сверх её содержимого.
+type FileMeta struct {
+	// Format — расширение без точки, в нижнем регистре.
+	Format string
+	// DurationMs — длительность, если её удалось прочитать.
+	DurationMs int64
+}
+
 type FileRepository interface {
 	// Stage принимает содержимое потоком в рабочую копию с заданным
 	// расширением: по нему внешняя программа выбирает разбор. В память запись
@@ -33,44 +40,96 @@ type FileRepository interface {
 	StageEmpty(ext string) (WorkFile, error)
 	// Localize выдаёт рабочую копию хранимого файла.
 	Localize(fileID string) (WorkFile, error)
-	// CreateLocal кладёт рабочую копию в хранилище под именем name и заводит
-	// запись о файле. Имя задаёт сервис: умолчание хранилища, строящее его из
-	// имени отправителя, не применяется.
+	// Create кладёт рабочую копию в хранилище под именем name и заводит запись о
+	// файле. Имя задаёт сервис: умолчание хранилища, строящее его из имени
+	// отправителя, не применяется.
 	//
 	// ownerID — владелец записи, которой файл принадлежит; пустой значит «файл
 	// без владельца», и таков всякий файл записи, принятой ботом. Владелец
-	// лежит своей колонкой, а не выводится через задачу: ссылку на файл в
-	// задаче переставляет каждый шаг конвейера, и исходная копия после
-	// конвертации не связана с задачей ничем.
-	CreateLocal(name string, work WorkFile, ownerID string) (*entity.File, error)
-	// CreateRemote заводит запись о копии, лежащей во внешнем хранилище.
-	CreateRemote(objectKey string, size int64, ownerID string) (*entity.File, error)
+	// лежит своей колонкой, а не выводится через запись: файл переживает свою
+	// запись — шаг заводит его до сохранения, и потерянный захват оставляет файл
+	// с владельцем и без ссылки.
+	Create(name string, work WorkFile, meta FileMeta, ownerID string) (*entity.File, error)
 	GetByID(id string) (*entity.File, error)
 	// Open отдаёт содержимое хранимого файла потоком.
 	Open(fileID string) (io.ReadCloser, error)
 }
 
-type TranscriptJobRepository interface {
-	Create(job *entity.TranscribeJob) error
-	// Save сохраняет задачу, захват которой держит holder. Захват, доставшийся
+// AcquiredRecord — то, что отдаёт захват: идентификатор записи и признак
+// **этого** захвата.
+//
+// Перечня колонок здесь нет намеренно. Захват, возвращавший колонки поимённо,
+// требовал править их в четырёх местах сразу, и забытая колонка приезжала
+// нулевой, а первое же сохранение писало этот ноль поверх значения. Колонки шаг
+// читает обычным чтением.
+type AcquiredRecord struct {
+	ID string
+	// Holder — значение, уникальное для каждого захвата. Запись результата
+	// условна по нему, а не по занятости записи: захват, перевыданный другому по
+	// протуханию срока или после снятия остановки человеком, обязан обратить
+	// запись первого в отказ.
+	Holder string
+}
+
+type AudioRecordRepository interface {
+	Create(record *entity.AudioRecord) error
+	// Save сохраняет запись, захват которой держит holder. Захват, доставшийся
 	// за время работы другому, даёт LostAcquisitionError и запись не проводит.
 	// Пустой holder снимает эту условность и в конвейере не употребляется: все
 	// его шаги получают признак захвата от FindAndAcquire.
-	Save(job *entity.TranscribeJob, holder string) error
-	// GetByID отдаёт задачу, только если её владелец — ownerID. Чужая задача,
-	// ничья задача и несуществующая дают одну и ту же ошибку: по разнице
-	// ответов иначе перебирается список заведённых задач.
+	Save(record *entity.AudioRecord, holder string) error
+	// GetByID отдаёт запись, только если её владелец — ownerID. Чужая запись,
+	// ничья и несуществующая дают одну и ту же ошибку: по разнице ответов иначе
+	// перебирается список заведённых записей.
 	//
 	// Владелец здесь обязателен, и пустой ownerID не совпадает ни с чем —
-	// включая задачи без владельца. Правило записано со стороны спрашивающего:
+	// включая записи без владельца. Правило записано со стороны спрашивающего:
 	// обязательность, которую держит одна лишь подпись метода, пустую строку
-	// пропускает, и вызывающий без учётной записи получил бы ровно множество
-	// записей бота.
+	// пропускает.
+	GetByID(id, ownerID string) (*entity.AudioRecord, error)
+	// Get отдаёт запись без сужения владельцем: им пользуется конвейер, чья
+	// выборка владельцем не сужается.
+	Get(id string) (*entity.AudioRecord, error)
+	// FindAndAcquire забирает пригодную к работе запись одним неделимым шагом и
+	// увеличивает число её отказов. Отбор идёт по рабочим рубежам, паузе, сроку
+	// протухания захвата и отсутствию признака остановки; срок протухания
+	// приезжает с рубежом и пишется в саму запись.
 	//
-	// Второго читающего метода нет намеренно: он выбирался бы по
-	// внимательности вызывающего.
-	GetByID(id, ownerID string) (*entity.TranscribeJob, error)
-	// FindAndAcquire забирает задачу одним неделимым шагом и увеличивает число
-	// её попыток. Работы в состоянии нет — JobNotFoundError.
-	FindAndAcquire(state, acquisitionId string, rottingTime time.Time) (*entity.TranscribeJob, error)
+	// Работы нет — JobNotFoundError.
+	FindAndAcquire(stages []entity.Stage) (*AcquiredRecord, error)
+}
+
+// TextRepository — тексты записи. Пара «запись и вид» уникальна: повтор
+// прерванного шага не заводит второй строки.
+type TextRepository interface {
+	Put(recordID, kind, contents string) (*entity.Text, error)
+	GetByID(id string) (*entity.Text, error)
+}
+
+// StructureRepository — структура реплик записи. Пара «запись и версия разбора»
+// уникальна по той же причине.
+type StructureRepository interface {
+	Put(recordID string, version int, replicas []entity.Replica) (*entity.Structure, error)
+	GetByID(id string) (*entity.Structure, error)
+}
+
+// RecognitionRepository — попытка распознавания у внешнего провайдера.
+type RecognitionRepository interface {
+	// Create заводит строку попытки **до** обращения к провайдеру: окно между
+	// его ответом и записью идентификатора — то место, где теряется оплаченное.
+	Create(recognition *entity.Recognition) error
+	// Submitted сохраняет адрес аудио и идентификатор заведённой операции. По
+	// последнему повторный шаг узнаёт, что за эту запись уже заплачено.
+	Submitted(id, sourceURI, externalID string) error
+	// Finish отмечает завершение операции и кладёт сырой ответ вложением.
+	Finish(id string, raw []byte) error
+	GetByID(id string) (*entity.Recognition, error)
+	// ReadRaw отдаёт сохранённый ответ провайдера. Зовётся только тогда, когда
+	// ответ нужен: шаг опроса читает строку попытки без него.
+	ReadRaw(id string) ([]byte, error)
+}
+
+// RecordEventRepository — журнал событий записи.
+type RecordEventRepository interface {
+	Append(event *entity.RecordEvent) error
 }

internal/controller/http/auth_test.go

@@ -38,7 +38,7 @@ func TestApiRequiresSession(t *testing.T) {
 		require.NoError(t, err)
 		assert.Empty(t, files)
 
-		jobs, err := env.app.FindAllRecords(migrations.JobsCollection)
+		jobs, err := env.app.FindAllRecords(migrations.RecordsCollection)
 		require.NoError(t, err)
 		assert.Empty(t, jobs)
 	})
@@ -64,7 +64,7 @@ func TestUnknownJobIsIndistinguishableWithoutSession(t *testing.T) {
 	env.serve(created, createMultipartRequest(t, "test.mp3", []byte("audio")))
 	require.Equal(t, http.StatusCreated, created.Code)
 
-	jobs, err := env.app.FindAllRecords(migrations.JobsCollection)
+	jobs, err := env.app.FindAllRecords(migrations.RecordsCollection)
 	require.NoError(t, err)
 	require.Len(t, jobs, 1)
 

internal/controller/http/login_test.go

@@ -188,7 +188,7 @@ func TestLoginCreatesAccountAndSession(t *testing.T) {
 
 	r, err := apis.NewRouter(env.app)
 	require.NoError(t, err)
-	NewTranscribeHandler(pbrepo.NewTranscriptJobRepository(env.app), nil, nil).Register(r)
+	NewTranscribeHandler(pbrepo.NewAudioRecordRepository(env.app), pbrepo.NewTextRepository(env.app), nil, nil).Register(r)
 	checkMux, err := r.BuildMux()
 	require.NoError(t, err)
 	checkMux.ServeHTTP(checkResponse, check)

internal/controller/http/ownership_test.go

@@ -12,6 +12,9 @@ import (
 	"github.com/stretchr/testify/require"
 
 	pbrepo "git.vakhrushev.me/av/transcriber/internal/adapter/repo/pocketbase"
+	"git.vakhrushev.me/av/transcriber/internal/adapter/repo/pocketbase/migrations"
+	"git.vakhrushev.me/av/transcriber/internal/clock"
+	"git.vakhrushev.me/av/transcriber/internal/contract"
 	"git.vakhrushev.me/av/transcriber/internal/entity"
 )
 
@@ -74,7 +77,7 @@ func TestGetTranscribeJobStatus_ForeignJobLooksMissing(t *testing.T) {
 	assert.JSONEq(t, unknown.Body.String(), foreign.Body.String(), "и тело то же")
 
 	// Ни состояния, ни текста расшифровки в теле нет.
-	assert.NotContains(t, foreign.Body.String(), entity.StateCreated)
+	assert.NotContains(t, foreign.Body.String(), entity.StateUploaded)
 	assert.NotContains(t, foreign.Body.String(), "transcription_text")
 }
 
@@ -88,15 +91,16 @@ func TestGetTranscribeJobStatus_OwnerlessJobLooksMissing(t *testing.T) {
 	defer func() { require.NoError(t, work.Close()) }()
 
 	// Файл записи из Telegram владельца тоже не имеет.
-	file, err := fileRepo.CreateLocal("voice.ogg", work, "")
+	file, err := fileRepo.Create("voice.ogg", work, contract.FileMeta{Format: "ogg"}, "")
 	require.NoError(t, err)
 
-	job := &entity.TranscribeJob{
-		State:  entity.StateCreated,
-		Source: entity.SourceTelegram,
-		FileID: &file.Id,
+	job := &entity.AudioRecord{
+		State:          entity.StateUploaded,
+		StateEnteredAt: clock.Now(),
+		Source:         entity.SourceTelegram,
+		OriginalFileID: &file.Id,
 	}
-	require.NoError(t, env.handler.jobRepo.Create(job))
+	require.NoError(t, env.handler.recordRepo.Create(job))
 
 	w := httptest.NewRecorder()
 	env.serve(w, httptest.NewRequest("GET", "/api/status/"+job.Id, http.NoBody))
@@ -116,11 +120,11 @@ func TestCreateTranscribeJob_OwnerIsSession(t *testing.T) {
 	var response CreateTranscribeJobResponse
 	require.NoError(t, json.Unmarshal(w.Body.Bytes(), &response))
 
-	record, err := env.app.FindRecordById("transcribe_jobs", response.JobID)
+	record, err := env.app.FindRecordById(migrations.RecordsCollection, response.JobID)
 	require.NoError(t, err)
 	assert.Equal(t, env.account.Id, record.GetString("owner"), "владелец задачи — предъявитель")
 
-	fileRecord, err := env.app.FindRecordById("files", record.GetString("file"))
+	fileRecord, err := env.app.FindRecordById("files", record.GetString("original_file"))
 	require.NoError(t, err)
 	assert.Equal(t, env.account.Id, fileRecord.GetString("owner"), "владелец файла — он же")
 }
@@ -143,7 +147,7 @@ func TestCreateTranscribeJob_OwnerFieldFromRequestIgnored(t *testing.T) {
 	var response CreateTranscribeJobResponse
 	require.NoError(t, json.Unmarshal(w.Body.Bytes(), &response))
 
-	record, err := env.app.FindRecordById("transcribe_jobs", response.JobID)
+	record, err := env.app.FindRecordById(migrations.RecordsCollection, response.JobID)
 	require.NoError(t, err)
 	assert.Equal(t, env.account.Id, record.GetString("owner"))
 }
@@ -187,7 +191,7 @@ func TestFileDownload_NarrowedByOwner(t *testing.T) {
 	job := jobWithFile(t, env)
 	_, stranger := newSecondAccount(t, env.app)
 
-	record, err := env.app.FindRecordById("files", *job.FileID)
+	record, err := env.app.FindRecordById("files", *job.OriginalFileID)
 	require.NoError(t, err)
 	require.Equal(t, env.account.Id, record.GetString("owner"))
 

internal/controller/http/status_test.go

@@ -0,0 +1,160 @@
+package http
+
+import (
+	"encoding/json"
+	"errors"
+	"log/slog"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/pocketbase/pocketbase/apis"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	pbrepo "git.vakhrushev.me/av/transcriber/internal/adapter/repo/pocketbase"
+	"git.vakhrushev.me/av/transcriber/internal/entity"
+)
+
+// Ответ об одной записи — то, ради чего эндпойнт и существует; ниже судятся его
+// ветки: готовый текст, остановленная запись и отказ хранилища на чтении текста.
+
+// statusOf спрашивает состояние записи от имени её владельца.
+func statusOf(t *testing.T, env *testEnv, recordID string) *httptest.ResponseRecorder {
+	t.Helper()
+
+	w := httptest.NewRecorder()
+	env.serve(w, httptest.NewRequest("GET", "/api/status/"+recordID, http.NoBody))
+	return w
+}
+
+// Готовая расшифровка доезжает до отправителя полем `transcription_text`, и
+// уходит в него **сырая** расшифровка: видов текста больше одного, и отдача
+// «последнего записанного» сделала бы ответ функцией порядка записи.
+func TestGetTranscribeJobStatus_ReturnsTranscript(t *testing.T) {
+	env := setupTestEnv(t, readableMetaViewer())
+
+	record := jobWithFile(t, env)
+
+	texts := pbrepo.NewTextRepository(env.app)
+	transcript, err := texts.Put(record.Id, entity.TextKindTranscript, "сырая расшифровка")
+	require.NoError(t, err)
+	literary, err := texts.Put(record.Id, entity.TextKindLiterary, "вычитанный текст")
+	require.NoError(t, err)
+
+	record.TranscriptTextID = &transcript.Id
+	record.LiteraryTextID = &literary.Id
+	record.MoveToState(entity.StateDone)
+	require.NoError(t, env.handler.recordRepo.Save(record, ""))
+
+	w := statusOf(t, env, record.Id)
+	require.Equal(t, http.StatusOK, w.Code)
+
+	var response GetTranscribeJobResponse
+	require.NoError(t, json.Unmarshal(w.Body.Bytes(), &response))
+
+	assert.Equal(t, entity.StateDone, response.State)
+	require.NotNil(t, response.TranscriptionText, "готовый текст доехал до отправителя")
+	assert.Equal(t, "сырая расшифровка", *response.TranscriptionText)
+	assert.NotContains(t, w.Body.String(), "вычитанный текст",
+		"вычитанный текст этим полем не подменяется: значение поля не должно меняться от того, успел ли необязательный шаг")
+}
+
+// Остановленная запись отдаёт рубеж, на котором встала, и признак остановки
+// отдельным полем: отказ перестал быть состоянием, и без признака такая запись
+// выглядела бы обычной, стоящей на своём рубеже.
+func TestGetTranscribeJobStatus_HaltedIsVisible(t *testing.T) {
+	env := setupTestEnv(t, readableMetaViewer())
+
+	record := jobWithFile(t, env)
+	record.MoveToState(entity.StateNormalized)
+	record.Halt(entity.HaltReasonStepFailed, "сбой конвертации файла")
+	require.NoError(t, env.handler.recordRepo.Save(record, ""))
+
+	w := statusOf(t, env, record.Id)
+	require.Equal(t, http.StatusOK, w.Code)
+
+	var response GetTranscribeJobResponse
+	require.NoError(t, json.Unmarshal(w.Body.Bytes(), &response))
+
+	assert.Equal(t, entity.StateNormalized, response.State, "рубеж тот, на котором запись встала")
+	assert.True(t, response.Halted, "признак остановки виден отправителю")
+	assert.NotContains(t, w.Body.String(), "сбой конвертации файла",
+		"машинный текст отказа принадлежит журналу владельца, а не ответу отправителю")
+}
+
+// Пока запись не дошла до текста, поля нет вовсе: пустая строка на его месте
+// читается как «расшифровка пуста».
+func TestGetTranscribeJobStatus_RunningRecordHasNoHaltedFlag(t *testing.T) {
+	env := setupTestEnv(t, readableMetaViewer())
+
+	record := jobWithFile(t, env)
+
+	w := statusOf(t, env, record.Id)
+	require.Equal(t, http.StatusOK, w.Code)
+
+	var response GetTranscribeJobResponse
+	require.NoError(t, json.Unmarshal(w.Body.Bytes(), &response))
+
+	assert.Equal(t, entity.StateUploaded, response.State)
+	assert.False(t, response.Halted, "запись в работе остановленной не значится")
+	assert.Nil(t, response.TranscriptionText)
+}
+
+// failingTextRepo отказывает на чтении текста — так выглядит недоступное
+// хранилище. Битую ссылку схема завести не даёт (связь проверяется при
+// сохранении), и это её защита, а не пробел: остаётся отказ самого чтения.
+type failingTextRepo struct{}
+
+func (r *failingTextRepo) Put(string, string, string) (*entity.Text, error) {
+	return nil, errors.New("не зовётся этой проверкой")
+}
+
+func (r *failingTextRepo) GetByID(string) (*entity.Text, error) {
+	return nil, errors.New("хранилище недоступно")
+}
+
+// Отказ чтения текста — это отказ хранилища, а не «записи нет». Отправителю он
+// приходит своим кодом, и владелец сервиса узнаёт об аварии из журнала — иначе
+// она читалась бы отправителю как «вашей записи не существует», а владельцем не
+// замечалась бы вовсе.
+func TestGetTranscribeJobStatus_TextReadFailureIsNotANotFound(t *testing.T) {
+	env := setupTestEnv(t, readableMetaViewer())
+
+	record := jobWithFile(t, env)
+
+	texts := pbrepo.NewTextRepository(env.app)
+	transcript, err := texts.Put(record.Id, entity.TextKindTranscript, "сырая расшифровка")
+	require.NoError(t, err)
+
+	record.TranscriptTextID = &transcript.Id
+	require.NoError(t, env.handler.recordRepo.Save(record, ""))
+
+	// Обработчик пересобирается с отказывающим хранилищем текстов: остальная
+	// цепочка та же, что и в проде.
+	journal := &journalBuffer{}
+	handler := NewTranscribeHandler(
+		env.handler.recordRepo,
+		&failingTextRepo{},
+		env.handler.trsService,
+		slog.New(slog.NewTextHandler(journal, nil)),
+	)
+
+	r, err := apis.NewRouter(env.app)
+	require.NoError(t, err)
+	handler.Register(r)
+	mux, err := r.BuildMux()
+	require.NoError(t, err)
+
+	req := httptest.NewRequest("GET", "/api/status/"+record.Id, http.NoBody)
+	req.AddCookie(&http.Cookie{Name: SessionCookieName, Value: env.session})
+	w := httptest.NewRecorder()
+	mux.ServeHTTP(w, req)
+
+	assert.Equal(t, http.StatusInternalServerError, w.Code,
+		"отказ хранилища не выдаётся за отсутствие записи")
+	assert.NotContains(t, w.Body.String(), "хранилище недоступно", "внутренности наружу не выходят")
+	assert.Contains(t, journal.String(), "Failed to read transcript",
+		"владелец сервиса узнаёт об аварии из журнала")
+}

internal/controller/http/transcribe.go

@@ -18,16 +18,22 @@ import (
 )
 
 type TranscribeHandler struct {
-	jobRepo    contract.TranscriptJobRepository
+	recordRepo contract.AudioRecordRepository
+	textRepo   contract.TextRepository
 	trsService *service.TranscribeService
 	logger     *slog.Logger
 }
 
-func NewTranscribeHandler(jobRepo contract.TranscriptJobRepository, trsService *service.TranscribeService, logger *slog.Logger) *TranscribeHandler {
+func NewTranscribeHandler(
+	recordRepo contract.AudioRecordRepository,
+	textRepo contract.TextRepository,
+	trsService *service.TranscribeService,
+	logger *slog.Logger,
+) *TranscribeHandler {
 	if logger == nil {
 		logger = slog.Default()
 	}
-	return &TranscribeHandler{jobRepo: jobRepo, trsService: trsService, logger: logger}
+	return &TranscribeHandler{recordRepo: recordRepo, textRepo: textRepo, trsService: trsService, logger: logger}
 }
 
 type CreateTranscribeJobResponse struct {
@@ -35,16 +41,27 @@ type CreateTranscribeJobResponse struct {
 	State string `json:"status"`
 }
 
+// GetTranscribeJobResponse — ответ об одной записи.
+//
+// Имена полей нормативны и остались прежними: контракт HTTP API объявлен
+// проектом необратимым, и переименование поля ломает внешнюю программу молча.
+// Изменились **значения** поля состояния — рубеж теперь называет достигнутое, — и
+// это объявленная ломка.
+//
+// Поле `halted` новое: отказ перестал быть состоянием, и без него остановленная
+// запись выглядела бы как обычная, стоящая на своём рубеже. Машинный текст
+// отказа в ответ не идёт: он принадлежит журналу владельца сервиса.
 type GetTranscribeJobResponse struct {
 	JobID             string    `json:"job_id"`
 	State             string    `json:"status"`
+	Halted            bool      `json:"halted"`
 	CreatedAt         time.Time `json:"created_at"`
 	TranscriptionText *string   `json:"transcription_text,omitempty"`
 }
 
 // Register вешает маршруты сервиса на роутер хранилища. Порт у сервиса и у
 // панели один, поэтому и роутер один; имена полей ответа и коды при переезде
-// сохранены — публичный контракт API объявлен необратимым.
+// сохранены — публичный контракт HTTP API объявлен необратимым.
 func (h *TranscribeHandler) Register(r *router.Router[*core.RequestEvent]) {
 	api := r.Group("/api")
 
@@ -80,18 +97,18 @@ func (h *TranscribeHandler) CreateTranscribeJob(e *core.RequestEvent) error {
 		}
 	}()
 
-	// Запись доехала целиком, поэтому задача заводится независимо от того,
-	// дождётся ли отправитель ответа: на контексте запроса приём терял бы
-	// полностью загруженную запись от одного обрыва соединения, а забрать
-	// результат он может и позже — по `GET /status/{id}`. Значения контекста
-	// (журнал запроса, сессия) при этом сохраняются, теряется только отмена.
+	// Запись доехала целиком, поэтому она заводится независимо от того, дождётся
+	// ли отправитель ответа: на контексте запроса приём терял бы полностью
+	// загруженную запись от одного обрыва соединения, а забрать результат он
+	// может и позже — по `GET /status/{id}`. Значения контекста (журнал запроса,
+	// сессия) при этом сохраняются, теряется только отмена.
 	ctx := context.WithoutCancel(e.Request.Context())
 
 	// Владелец берётся из предъявленной сессии и ниоткуда больше: владелец,
 	// пришедший полем запроса, дал бы всякому вошедшему право завести запись на
 	// чужое имя. Проверка предъявителя стоит слоем выше, поэтому здесь `e.Auth`
 	// уже есть и принадлежит коллекции пользователей.
-	job, err := h.trsService.CreateJobFromApi(ctx, file, header.Filename, e.Auth.Id)
+	record, err := h.trsService.CreateJobFromApi(ctx, file, header.Filename, e.Auth.Id)
 	if err != nil {
 		// Второй раз отказ не логируем: приём назван конвенцией логирующей
 		// границей и уже написал о нём. Транспорт переводит ошибку в ответ.
@@ -100,37 +117,53 @@ func (h *TranscribeHandler) CreateTranscribeJob(e *core.RequestEvent) error {
 
 	// Возвращаем успешный ответ
 	return e.JSON(http.StatusCreated, CreateTranscribeJobResponse{
-		JobID: job.Id,
-		State: job.State,
+		JobID: record.Id,
+		State: record.State,
 	})
 }
 
 func (h *TranscribeHandler) GetTranscribeJobStatus(e *core.RequestEvent) error {
-	jobID := e.Request.PathValue("id")
+	recordID := e.Request.PathValue("id")
 
-	// Чужая задача, задача без владельца и несуществующая отвечают одним и тем
+	// Чужая запись, запись без владельца и несуществующая отвечают одним и тем
 	// же: хранилище отдаёт на все три ту же ошибку, а транспорт — тот же код и
 	// то же тело. Различать их наружу нельзя — по разнице ответов перебирается
-	// список заведённых задач.
-	job, err := h.jobRepo.GetByID(jobID, e.Auth.Id)
+	// список заведённых записей.
+	record, err := h.recordRepo.GetByID(recordID, e.Auth.Id)
 	if err != nil {
 		// Наружу ответ один на все исходы, а в журнал они идут по-разному.
-		// «Задачи нет» и «задача чужая» — штатная работа разграничения, о ней
+		// «Записи нет» и «запись чужая» — штатная работа разграничения, о ней
 		// писать нечего; всё прочее — отказ хранилища, и без этой строки он
 		// приходит отправителю как «вашей записи нет», а владелец сервиса об
-		// аварии не узнаёт ниоткуда. Журнал читает владелец, а не тот, кто
-		// перебирает, поэтому различать их здесь можно.
+		// аварии не узнаёт ниоткуда.
 		var notFound *contract.JobNotFoundError
 		if !errors.As(err, &notFound) {
-			h.logger.Error("Failed to read transcribe job", "error", err, "job_id", jobID)
+			h.logger.Error("Failed to read audio record", "error", err, "record_id", recordID)
 		}
 		return e.JSON(http.StatusNotFound, map[string]string{"error": "Job not found"})
 	}
 
-	return e.JSON(http.StatusOK, GetTranscribeJobResponse{
-		JobID:             job.Id,
-		State:             job.State,
-		CreatedAt:         job.CreatedAt,
-		TranscriptionText: job.TranscriptionText,
-	})
+	response := GetTranscribeJobResponse{
+		JobID:     record.Id,
+		State:     record.State,
+		Halted:    record.IsHalted(),
+		CreatedAt: record.CreatedAt,
+	}
+
+	// Вид текста называется **явно**: видов у записи больше одного, и отдача
+	// «последнего записанного» сделала бы ответ функцией порядка записи, а не
+	// состояния записи. В это поле уходит сырая расшифровка, и только она.
+	if record.TranscriptTextID != nil {
+		text, err := h.textRepo.GetByID(*record.TranscriptTextID)
+		if err != nil {
+			h.logger.Error("Failed to read transcript", "error", err, "record_id", recordID)
+			return e.JSON(http.StatusInternalServerError, map[string]string{"error": "Failed to read transcription"})
+		}
+		if text.Contents != "" {
+			contents := text.Contents
+			response.TranscriptionText = &contents
+		}
+	}
+
+	return e.JSON(http.StatusOK, response)
 }

internal/controller/http/transcribe_test.go

@@ -14,6 +14,7 @@ import (
 	"strings"
 	"sync"
 	"testing"
+	"time"
 
 	"github.com/pocketbase/pocketbase/apis"
 	"github.com/pocketbase/pocketbase/core"
@@ -24,6 +25,7 @@ import (
 	"git.vakhrushev.me/av/transcriber/internal/adapter/recognizer"
 	pbrepo "git.vakhrushev.me/av/transcriber/internal/adapter/repo/pocketbase"
 	"git.vakhrushev.me/av/transcriber/internal/adapter/repo/pocketbase/migrations"
+	"git.vakhrushev.me/av/transcriber/internal/clock"
 	"git.vakhrushev.me/av/transcriber/internal/contract"
 	"git.vakhrushev.me/av/transcriber/internal/entity"
 	"git.vakhrushev.me/av/transcriber/internal/service"
@@ -167,8 +169,16 @@ func setupTestEnv(t *testing.T, metaviewer contract.AudioMetaViewer) *testEnv {
 
 	pbrepo.BindPanelRules(app)
 
-	fileRepo := pbrepo.NewFileRepository(app)
-	jobRepo := pbrepo.NewTranscriptJobRepository(app)
+	recordRepo := pbrepo.NewAudioRecordRepository(app)
+	textRepo := pbrepo.NewTextRepository(app)
+	repos := service.Repositories{
+		Records:      recordRepo,
+		Files:        pbrepo.NewFileRepository(app),
+		Texts:        textRepo,
+		Structures:   pbrepo.NewStructureRepository(app),
+		Recognitions: pbrepo.NewRecognitionRepository(app),
+		Events:       pbrepo.NewRecordEventRepository(app),
+	}
 
 	// Журнал уходит в буфер, а не в никуда: по нему судит проверка запрета на
 	// имя отправителя. Вывод прогона от этого не меняется — ERROR-строки ветки
@@ -178,16 +188,16 @@ func setupTestEnv(t *testing.T, metaviewer contract.AudioMetaViewer) *testEnv {
 	logger := slog.New(slog.NewTextHandler(journal, nil))
 
 	trsService := service.NewTranscribeService(
-		jobRepo,
-		fileRepo,
+		repos,
 		metaviewer,
 		&stubConverter{},
 		&recognizer.MemoryAudioRecognizer{},
 		&TestTgSender{},
+		entity.StuckLimits{Own: time.Hour, Foreign: 24 * time.Hour},
 		logger,
 	)
 
-	handler := NewTranscribeHandler(jobRepo, trsService, logger)
+	handler := NewTranscribeHandler(recordRepo, textRepo, trsService, logger)
 
 	// Роутер собирается тем же способом, что и боевой: маршруты вешает сам
 	// обработчик, и проверка судит ту же цепочку, что и прод.
@@ -256,16 +266,16 @@ func countFiles(t *testing.T, env *testEnv) int {
 	return len(records)
 }
 
-// countJobs считает заведённые задачи расшифровки.
+// countJobs считает заведённые аудиозаписи.
 func countJobs(t *testing.T, env *testEnv) int {
-	records, err := env.app.FindAllRecords(migrations.JobsCollection)
+	records, err := env.app.FindAllRecords(migrations.RecordsCollection)
 	require.NoError(t, err)
 	return len(records)
 }
 
 // jobWithFile заводит задачу вместе с её записью: ссылка на файл обязательна
 // схемой, потому что без неё задача не пройдёт ни одного шага.
-func jobWithFile(t *testing.T, env *testEnv) *entity.TranscribeJob {
+func jobWithFile(t *testing.T, env *testEnv) *entity.AudioRecord {
 	t.Helper()
 
 	repo := pbrepo.NewFileRepository(env.app)
@@ -276,17 +286,18 @@ func jobWithFile(t *testing.T, env *testEnv) *entity.TranscribeJob {
 	// Владелец — учётная запись проверки: задача, пришедшая из веба, без
 	// владельца больше не заводится, и фикстура без него описывала бы состояние,
 	// которого в проде не бывает.
-	file, err := repo.CreateLocal("sample.mp3", work, env.account.Id)
+	file, err := repo.Create("sample.mp3", work, contract.FileMeta{Format: "mp3"}, env.account.Id)
 	require.NoError(t, err)
 
-	job := &entity.TranscribeJob{
-		State:   entity.StateCreated,
-		Source:  entity.SourceApi,
-		OwnerID: &env.account.Id,
-		FileID:  &file.Id,
+	record := &entity.AudioRecord{
+		State:          entity.StateUploaded,
+		StateEnteredAt: clock.Now(),
+		Source:         entity.SourceApi,
+		OwnerID:        &env.account.Id,
+		OriginalFileID: &file.Id,
 	}
-	require.NoError(t, env.handler.jobRepo.Create(job))
-	return job
+	require.NoError(t, env.handler.recordRepo.Create(record))
+	return record
 }
 
 // storedContent читает содержимое файла из хранилища.
@@ -327,21 +338,21 @@ func TestCreateTranscribeJob_Success(t *testing.T) {
 	require.NoError(t, err)
 
 	assert.NotEmpty(t, response.JobID)
-	assert.Equal(t, entity.StateCreated, response.State)
+	assert.Equal(t, entity.StateUploaded, response.State)
 
 	// Задача действительно заведена, а не только названа в ответе: иначе
 	// отправитель получит идентификатор записи, которой не будет никогда.
 	require.Equal(t, 1, countJobs(t, env))
 
-	job, err := env.handler.jobRepo.GetByID(response.JobID, env.account.Id)
+	job, err := env.handler.recordRepo.GetByID(response.JobID, env.account.Id)
 	require.NoError(t, err)
-	assert.Equal(t, entity.StateCreated, job.State)
-	require.NotNil(t, job.FileID)
-	assert.NotEmpty(t, *job.FileID)
+	assert.Equal(t, entity.StateUploaded, job.State)
+	require.NotNil(t, job.OriginalFileID)
+	assert.NotEmpty(t, *job.OriginalFileID)
 
 	// Содержимое лежит в хранилище одним файлом и целиком.
 	require.Equal(t, 1, countFiles(t, env))
-	assert.Equal(t, content, storedContent(t, env, *job.FileID))
+	assert.Equal(t, content, storedContent(t, env, *job.OriginalFileID))
 }
 
 func TestCreateTranscribeJob_NoFile(t *testing.T) {
@@ -404,7 +415,7 @@ func TestCreateTranscribeJob_EmptyFile(t *testing.T) {
 	require.NoError(t, err)
 
 	assert.NotEmpty(t, response.JobID)
-	assert.Equal(t, entity.StateCreated, response.State)
+	assert.Equal(t, entity.StateUploaded, response.State)
 }
 
 func TestCreateTranscribeJob_DifferentFileExtensions(t *testing.T) {
@@ -513,7 +524,7 @@ const senderNameMarker = "SENDERNAMELEAKMARKER7Q2"
 // долг `docs/conventions/logging.md`: `msg` обязан стать короткой категорией.
 // Когда долг закроют, правка будет здесь и одна.
 const (
-	msgIntake = "Creating transcribe job"
+	msgIntake = "Creating audio record"
 	// Отказ пишет доменная граница — приём, — а не транспорт: конвенция просит
 	// логировать ошибку один раз, и повторная запись транспорта снята.
 	msgIntakeErr = "Failed to get file info"
@@ -603,15 +614,15 @@ func TestCreateTranscribeJob_JournalTracesRecord(t *testing.T) {
 	var response CreateTranscribeJobResponse
 	require.NoError(t, json.Unmarshal(w.Body.Bytes(), &response))
 
-	job, err := env.handler.jobRepo.GetByID(response.JobID, env.account.Id)
+	job, err := env.handler.recordRepo.GetByID(response.JobID, env.account.Id)
 	require.NoError(t, err)
-	require.NotNil(t, job.FileID)
+	require.NotNil(t, job.OriginalFileID)
 
 	// Отбор по идентификатору **этого** прогона: иначе утверждение прошло бы по
 	// строке, оставленной соседней проверкой, и прослеживаемость числилась бы
 	// сохранённой при пустом журнале.
 	journal := env.journal.String()
-	assert.Contains(t, journal, *job.FileID, "по журналу видно, какой файл заведён")
+	assert.Contains(t, journal, *job.OriginalFileID, "по журналу видно, какой файл заведён")
 	assert.Contains(t, journal, ".mp3", "расширение принятой записи в журнале остаётся")
 
 	// Разделитель ключа и значения задаёт обработчик: сегодня текстовый, по
@@ -698,7 +709,7 @@ func TestGetTranscribeJobStatus_Success(t *testing.T) {
 	require.NoError(t, json.Unmarshal(w.Body.Bytes(), &response))
 
 	assert.Equal(t, job.Id, response.JobID)
-	assert.Equal(t, entity.StateCreated, response.State)
+	assert.Equal(t, entity.StateUploaded, response.State)
 	assert.NotZero(t, response.CreatedAt)
 }
 
@@ -761,7 +772,7 @@ func TestAcceptedRecordSurvivesSenderDisconnect(t *testing.T) {
 
 	require.Equal(t, http.StatusCreated, w.Result().StatusCode, "тело ответа: %s", w.Body.String())
 
-	jobs, err := env.app.FindAllRecords(migrations.JobsCollection)
+	jobs, err := env.app.FindAllRecords(migrations.RecordsCollection)
 	require.NoError(t, err)
 	assert.Len(t, jobs, 1, "задача заведена, несмотря на ушедшего отправителя")
 }

internal/controller/tg/tg.go

@@ -16,7 +16,6 @@ import (
 	// адаптера» правилом не держится и уже нарушено HTTP-поверхностью
 	// (docs/conventions/go-linters.md, «Что остаётся прозой»).
 	"git.vakhrushev.me/av/transcriber/internal/adapter/telegram"
-	"git.vakhrushev.me/av/transcriber/internal/contract"
 	"git.vakhrushev.me/av/transcriber/internal/service"
 	tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
 )
@@ -24,7 +23,6 @@ import (
 type TelegramController struct {
 	// deps
 	transcribeService *service.TranscribeService
-	jobRepo           contract.TranscriptJobRepository
 	logger            *slog.Logger
 	// params
 	bot           *tgbotapi.BotAPI
@@ -44,7 +42,6 @@ func NewTelegramController(
 	config TelegramConfig,
 	bot *tgbotapi.BotAPI,
 	transcribeService *service.TranscribeService,
-	jobRepo contract.TranscriptJobRepository,
 	logger *slog.Logger,
 ) (*TelegramController, error) {
 	if bot == nil {
@@ -54,7 +51,6 @@ func NewTelegramController(
 	controller := &TelegramController{
 		bot:               bot,
 		transcribeService: transcribeService,
-		jobRepo:           jobRepo,
 		logger:            logger,
 		updateTimeout:     config.UpdateTimeout,
 		userWhiteList:     config.UserWhiteList,
@@ -178,16 +174,16 @@ func (c *TelegramController) handleAudioMessage(ctx context.Context, message *tg
 	defer fileReader.Close()
 
 	// Обрабатываем файл
-	job, err := c.transcribeService.CreateJobFromTelegram(ctx, fileReader, fileName, message.Chat.ID, sentProgressMsg.MessageID)
+	record, err := c.transcribeService.CreateJobFromTelegram(ctx, fileReader, fileName, message.Chat.ID, sentProgressMsg.MessageID)
 	if err != nil {
-		c.logger.Error("Failed to create transcribe job", "error", err)
+		c.logger.Error("Failed to create audio record", "error", err)
 		errorMsg := tgbotapi.NewMessage(message.Chat.ID, "Ошибка при создании задачи на расшифровку. Попробуйте еще раз.")
 		c.send(errorMsg)
 		return
 	}
 
 	// Отправляем сообщение об успешном создании задачи
-	successMsg := tgbotapi.NewMessage(message.Chat.ID, fmt.Sprintf("Задача на расшифровку создана. ID задачи: %s", job.Id))
+	successMsg := tgbotapi.NewMessage(message.Chat.ID, fmt.Sprintf("Задача на расшифровку создана. ID задачи: %s", record.Id))
 	successMsg.ReplyToMessageID = message.MessageID
 	c.send(successMsg)
 }
@@ -213,16 +209,16 @@ func (c *TelegramController) handleVoiceMessage(ctx context.Context, message *tg
 	defer fileReader.Close()
 
 	// Обрабатываем файл
-	job, err := c.transcribeService.CreateJobFromTelegram(ctx, fileReader, fileName, message.Chat.ID, sentProgressMsg.MessageID)
+	record, err := c.transcribeService.CreateJobFromTelegram(ctx, fileReader, fileName, message.Chat.ID, sentProgressMsg.MessageID)
 	if err != nil {
-		c.logger.Error("Failed to create transcribe job", "error", err)
+		c.logger.Error("Failed to create audio record", "error", err)
 		errorMsg := tgbotapi.NewMessage(message.Chat.ID, "Ошибка при создании задачи на расшифровку. Попробуйте еще раз.")
 		c.send(errorMsg)
 		return
 	}
 
 	// Отправляем сообщение об успешном создании задачи
-	successMsg := tgbotapi.NewMessage(message.Chat.ID, fmt.Sprintf("Задача на расшифровку создана. ID задачи: %s", job.Id))
+	successMsg := tgbotapi.NewMessage(message.Chat.ID, fmt.Sprintf("Задача на расшифровку создана. ID задачи: %s", record.Id))
 	successMsg.ReplyToMessageID = message.MessageID
 	c.send(successMsg)
 }
@@ -253,16 +249,16 @@ func (c *TelegramController) handleDocumentMessage(ctx context.Context, message
 	defer fileReader.Close()
 
 	// Обрабатываем файл
-	job, err := c.transcribeService.CreateJobFromTelegram(ctx, fileReader, fileName, message.Chat.ID, sentProgressMsg.MessageID)
+	record, err := c.transcribeService.CreateJobFromTelegram(ctx, fileReader, fileName, message.Chat.ID, sentProgressMsg.MessageID)
 	if err != nil {
-		c.logger.Error("Failed to create transcribe job", "error", err)
+		c.logger.Error("Failed to create audio record", "error", err)
 		errorMsg := tgbotapi.NewMessage(message.Chat.ID, "Ошибка при создании задачи на расшифровку. Попробуйте еще раз.")
 		c.send(errorMsg)
 		return
 	}
 
 	// Отправляем сообщение об успешном создании задачи
-	successMsg := tgbotapi.NewMessage(message.Chat.ID, fmt.Sprintf("Задача на расшифровку создана. ID задачи: %s", job.Id))
+	successMsg := tgbotapi.NewMessage(message.Chat.ID, fmt.Sprintf("Задача на расшифровку создана. ID задачи: %s", record.Id))
 	successMsg.ReplyToMessageID = message.MessageID
 	c.send(successMsg)
 }

internal/controller/worker/pool_test.go

@@ -0,0 +1,129 @@
+package worker
+
+import (
+	"context"
+	"log/slog"
+	"sync/atomic"
+	"testing"
+	"time"
+)
+
+// Пул — предмет этой работы: воркеров стало сколько угодно одинаковых вместо
+// трёх именованных. Проверки ниже судят саму обвязку — подъём, остановку и
+// нулевой размер, — а не шаг, который она крутит: шаг судят проверки конвейера.
+
+// countingStep считает свои вызовы и отпускает проверку, когда их набралось
+// достаточно.
+func countingStep(t *testing.T, enough int64) (func(context.Context) error, <-chan struct{}, *atomic.Int64) {
+	t.Helper()
+
+	var calls atomic.Int64
+	done := make(chan struct{})
+	var closed atomic.Bool
+
+	return func(context.Context) error {
+		if calls.Add(1) >= enough && closed.CompareAndSwap(false, true) {
+			close(done)
+		}
+		return nil
+	}, done, &calls
+}
+
+// Пул поднимает столько воркеров, сколько ему назвали, и все они крутят шаг.
+func TestPoolRunsEveryWorker(t *testing.T) {
+	const size = 4
+
+	step, done, calls := countingStep(t, size)
+	pool := NewPool(size, step, slog.New(slog.DiscardHandler))
+	for _, w := range pool.workers {
+		w.interval = time.Millisecond
+	}
+
+	if pool.Size() != size {
+		t.Fatalf("в пуле %d воркеров вместо %d", pool.Size(), size)
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	finished := make(chan struct{})
+	go func() {
+		pool.Start(ctx)
+		close(finished)
+	}()
+
+	select {
+	case <-done:
+	case <-time.After(5 * time.Second):
+		t.Fatalf("шаг позвали %d раз вместо %d: не все воркеры поднялись", calls.Load(), size)
+	}
+
+	cancel()
+
+	select {
+	case <-finished:
+	case <-time.After(5 * time.Second):
+		t.Fatal("пул не дождался остановки воркеров: горутина осталась висеть")
+	}
+}
+
+// Нулевой пул — законный режим, а не поломка: сервис поднимается, записи
+// принимаются и не двигаются. Проверка судит именно это: шаг не зовётся ни разу,
+// а подъём не блокируется.
+func TestZeroPoolRunsNothingAndReturns(t *testing.T) {
+	var calls atomic.Int64
+	pool := NewPool(0, func(context.Context) error {
+		calls.Add(1)
+		return nil
+	}, slog.New(slog.DiscardHandler))
+
+	if pool.Size() != 0 {
+		t.Fatalf("пустой пул завёл %d воркеров", pool.Size())
+	}
+
+	finished := make(chan struct{})
+	go func() {
+		pool.Start(context.Background())
+		close(finished)
+	}()
+
+	select {
+	case <-finished:
+	case <-time.After(5 * time.Second):
+		t.Fatal("пустой пул не вернул управление: подъём сервиса заблокирован")
+	}
+
+	if got := calls.Load(); got != 0 {
+		t.Errorf("шаг позвали %d раз при нулевом пуле", got)
+	}
+}
+
+// Отменённый контекст останавливает **всех** воркеров пула: забытая горутина не
+// падает и не пишет, а держит процесс и продолжает опрашивать базу после
+// остановки сервиса.
+func TestPoolStopsEveryWorkerOnCancel(t *testing.T) {
+	const size = 3
+
+	step, done, _ := countingStep(t, size)
+	pool := NewPool(size, step, slog.New(slog.DiscardHandler))
+	for _, w := range pool.workers {
+		w.interval = time.Millisecond
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+
+	finished := make(chan struct{})
+	go func() {
+		pool.Start(ctx)
+		close(finished)
+	}()
+
+	<-done
+	cancel()
+
+	select {
+	case <-finished:
+	case <-time.After(5 * time.Second):
+		t.Fatal("пул не остановился по отмене контекста")
+	}
+}

internal/controller/worker/worker.go

@@ -3,26 +3,25 @@ package worker
 import (
 	"context"
 	"errors"
+	"fmt"
 	"log/slog"
-	"strconv"
+	"sync"
 	"time"
 
 	"git.vakhrushev.me/av/transcriber/internal/contract"
-	"git.vakhrushev.me/av/transcriber/internal/metrics"
 )
 
-// Worker представляет базовый интерфейс для всех воркеров
-type Worker interface {
-	Start(ctx context.Context)
-	Name() string
-}
-
 // pollInterval — пауза между прогонами шага. Полем, а не константой по месту:
 // проверке нужен второй прогон, чтобы остановить воркер **после** того, как он
 // рассудил об исходе первого. Отменять контекст изнутри шага она не может —
 // отменённый контекст теперь и значит «нас остановили».
 const pollInterval = time.Second
 
+// CallbackWorker крутит один и тот же шаг, опрашивая очередь.
+//
+// Специализации у него нет: шаг сам берёт любую пригодную к работе запись и
+// выбирает работу по её рубежу. Раньше воркеров было три именованных, по одному
+// на состояние, и каждый новый рубеж требовал четвёртого.
 type CallbackWorker struct {
 	name string
 	// Шаг принимает контекст воркера: остановка обязана доходить до чужой
@@ -64,15 +63,12 @@ func (w *CallbackWorker) Start(ctx context.Context) {
 			// первой же обёртки `%w`, которая в проекте — умолчание.
 			var noop *contract.NoopJobError
 			isNoop := errors.As(err, &noop)
-			// Остановка — не отказ шага: контекст отменили мы сами. Считать её
-			// в метрику и писать владельцу «Worker error» значит красить каждую
-			// выкладку как поломку — по тому же доводу, по которому не считается
+			// Остановка — не отказ шага: контекст отменили мы сами. Писать
+			// владельцу «Worker error» значит красить каждую выкладку как
+			// поломку — по тому же доводу, по которому не считается
 			// `NoopJobError`. Судит контекст, а не текст ошибки: убитый процесс
 			// отдаёт «signal: killed», и `errors.Is` его с отменой не свяжет.
 			stopped := err != nil && !isNoop && ctx.Err() != nil
-			if !isNoop && !stopped {
-				metrics.WorkerJobCounter.WithLabelValues(w.Name(), strconv.FormatBool(err != nil)).Inc()
-			}
 			if err != nil && !isNoop && !stopped {
 				w.logger.Error("Worker error", "worker", w.Name(), "error", err)
 			}
@@ -80,6 +76,9 @@ func (w *CallbackWorker) Start(ctx context.Context) {
 				w.logger.Info("Worker step interrupted by shutdown", "worker", w.Name())
 			}
 
+			// Счётчик работы растит сам шаг: только он знает рубеж, с которого
+			// взята запись, а воркер к рубежу больше не привязан.
+
 			// Ждем перед следующей итерацией
 			select {
 			case <-ctx.Done():
@@ -91,3 +90,51 @@ func (w *CallbackWorker) Start(ctx context.Context) {
 		}
 	}
 }
+
+// Pool — пул одинаковых воркеров конвейера.
+//
+// Число задаётся настройкой, и ноль — законное значение: сервис поднимается,
+// записи принимаются и не двигаются. Это режим, а не поломка: он нужен местному
+// запуску и выкладке, где конвейер надо остановить, не роняя приём.
+type Pool struct {
+	workers []*CallbackWorker
+	logger  *slog.Logger
+}
+
+// NewPool собирает пул из size одинаковых воркеров, крутящих один и тот же шаг.
+func NewPool(size int, step func(ctx context.Context) error, logger *slog.Logger) *Pool {
+	if logger == nil {
+		logger = slog.Default()
+	}
+
+	workers := make([]*CallbackWorker, 0, size)
+	for i := range size {
+		workers = append(workers, NewCallbackWorker(fmt.Sprintf("pipeline_worker_%d", i+1), step, logger))
+	}
+
+	return &Pool{workers: workers, logger: logger}
+}
+
+// Size — сколько воркеров в пуле.
+func (p *Pool) Size() int { return len(p.workers) }
+
+// Start поднимает всех воркеров пула и ждёт их остановки.
+func (p *Pool) Start(ctx context.Context) {
+	if len(p.workers) == 0 {
+		// Молчать нельзя: пустой пул неотличим от поломки, а объявленный режим
+		// обязан быть назван.
+		p.logger.Info("Pipeline workers are disabled by configuration")
+		return
+	}
+
+	var wg sync.WaitGroup
+	for _, w := range p.workers {
+		wg.Add(1)
+		go func(worker *CallbackWorker) {
+			defer wg.Done()
+			worker.Start(ctx)
+			p.logger.Info("Worker stopped gracefully", "worker", worker.Name())
+		}(w)
+	}
+	wg.Wait()
+}

internal/controller/worker/worker_test.go

@@ -11,14 +11,17 @@ import (
 	"time"
 
 	"git.vakhrushev.me/av/transcriber/internal/contract"
-	"github.com/prometheus/client_golang/prometheus"
 )
 
 // Проверки этого файла судят одну развилку воркера: пустой прогон против
 // отказа. Инвариант проекта — «NoopJobError не ошибка» — стоит ровно на ней, а
-// цена срабатывания отложенная: три воркера опрашивают базу раз в секунду, и
-// пустой прогон, принятый за отказ, даёт три записи в секунду и столько же
+// цена срабатывания отложенная: воркеры опрашивают базу раз в секунду, и пустой
+// прогон, принятый за отказ, даёт запись в секунду с каждого и столько же
 // засчитанных сбоев, которых не было.
+//
+// Счёт работы здесь не судится: он переехал в шаг конвейера вместе с меткой
+// рубежа. Воркер к рубежу не привязан и назвать его не может, а метка,
+// выведенная из имени потока, перестала что-либо значить с появлением пула.
 
 // journalBuffer собирает журнал прогона. Пишут в него из горутины воркера, а
 // читает проверка — отсюда мьютекс.
@@ -113,39 +116,6 @@ func runRecords(journal string) string {
 	return strings.Join(kept, "\n")
 }
 
-// jobCount читает счётчик работы воркера из общего реестра процесса. Судит
-// реестр, а не переменную пакета: метка, потерянная в точке употребления,
-// переменную не ломает, а на странице метрик видна.
-func jobCount(t *testing.T, worker, errLabel string) float64 {
-	t.Helper()
-
-	families, err := prometheus.DefaultGatherer.Gather()
-	if err != nil {
-		t.Fatalf("не удалось собрать метрики: %v", err)
-	}
-
-	for _, mf := range families {
-		if mf.GetName() != "transcriber_worker_job_count" {
-			continue
-		}
-		for _, m := range mf.GetMetric() {
-			var gotWorker, gotErr string
-			for _, label := range m.GetLabel() {
-				switch label.GetName() {
-				case "name":
-					gotWorker = label.GetValue()
-				case "error":
-					gotErr = label.GetValue()
-				}
-			}
-			if gotWorker == worker && gotErr == errLabel {
-				return m.GetCounter().GetValue()
-			}
-		}
-	}
-	return 0
-}
-
 // Обёртка `%w` объявлена конвенцией проекта умолчанием, и до этой задачи первая
 // же обёртка на пути сломала бы распознавание молча. Оракул держит именно
 // обёрнутое значение: на голом признак узнавался и приведением типа, то есть
@@ -153,11 +123,8 @@ func jobCount(t *testing.T, worker, errLabel string) float64 {
 func TestWrappedNoopIsNotAFailure(t *testing.T) {
 	const name = "wrapped_noop_worker"
 
-	before := jobCount(t, name, "false")
-	beforeErr := jobCount(t, name, "true")
-
 	journal := runOnce(t, name, func(context.Context) error {
-		return fmt.Errorf("find and acquire job: %w", &contract.NoopJobError{State: "created"})
+		return fmt.Errorf("find and acquire record: %w", &contract.NoopJobError{State: "uploaded"})
 	})
 
 	// Записи о старте и остановке воркера законны и к прогону не относятся —
@@ -165,21 +132,13 @@ func TestWrappedNoopIsNotAFailure(t *testing.T) {
 	if got := runRecords(journal); got != "" {
 		t.Errorf("пустой прогон попал в журнал: %q", got)
 	}
-	if got := jobCount(t, name, "false"); got != before {
-		t.Errorf("счётчик успешных прогонов вырос на пустом прогоне: было %v, стало %v", before, got)
-	}
-	if got := jobCount(t, name, "true"); got != beforeErr {
-		t.Errorf("пустой прогон засчитан отказом: было %v, стало %v", beforeErr, got)
-	}
 }
 
-// Без этой проверки оракул был бы зелен и на коде, который не считает отказом
-// вообще ничего.
-func TestFailureIsLoggedAndCounted(t *testing.T) {
+// Без этой проверки оракул был бы зелен и на коде, который не пишет об отказе
+// вообще ничего. Счёт отказа судит проверка шага: метку рубежа знает он.
+func TestFailureIsLogged(t *testing.T) {
 	const name = "failing_worker"
 
-	before := jobCount(t, name, "true")
-
 	journal := runOnce(t, name, func(context.Context) error {
 		return errors.New("database is gone")
 	})
@@ -187,42 +146,28 @@ func TestFailureIsLoggedAndCounted(t *testing.T) {
 	if !strings.Contains(journal, "database is gone") {
 		t.Errorf("отказ не виден владельцу: журнал %q", journal)
 	}
-	if got := jobCount(t, name, "true"); got != before+1 {
-		t.Errorf("отказ не засчитан: было %v, стало %v", before, got)
-	}
 }
 
-// Счёт успешных прогонов — знаменатель доли отказов. Реализация, снявшая его,
-// проходит обе проверки выше, а владелец теряет способность отличить «три
-// прогона в секунду, все отказали» от «три отказа среди тысячи прогонов».
-func TestSuccessIsCounted(t *testing.T) {
+// Успешный прогон отказом не записывается.
+func TestSuccessIsNotLoggedAsFailure(t *testing.T) {
 	const name = "successful_worker"
 
-	before := jobCount(t, name, "false")
-
 	journal := runOnce(t, name, func(context.Context) error {
 		return nil
 	})
 
-	if got := jobCount(t, name, "false"); got != before+1 {
-		t.Errorf("успешный прогон не засчитан: было %v, стало %v", before, got)
-	}
 	if strings.Contains(journal, "Worker error") {
 		t.Errorf("успешный прогон записан отказом: журнал %q", journal)
 	}
 }
 
 // Остановка сервиса — не отказ шага: контекст отменили мы сами. Без этой
-// развилки каждая выкладка красит журнал владельца отказами и накручивает
-// счётчик сбоев, которых не было, — тот же довод, по которому не считается
-// `NoopJobError`. Судит контекст, а не текст ошибки: убитый по контексту
+// развилки каждая выкладка красит журнал владельца отказами, — тот же довод, по
+// которому не пишется `NoopJobError`. Судит контекст, а не текст ошибки: убитый по контексту
 // процесс отдаёт «signal: killed», и `errors.Is` его с отменой не свяжет.
 func TestShutdownIsNotAFailure(t *testing.T) {
 	const name = "stopped_worker"
 
-	beforeErr := jobCount(t, name, "true")
-	beforeOk := jobCount(t, name, "false")
-
 	journal := &journalBuffer{}
 	logger := slog.New(slog.NewTextHandler(journal, nil))
 
@@ -251,10 +196,4 @@ func TestShutdownIsNotAFailure(t *testing.T) {
 	if got := journal.String(); strings.Contains(got, "Worker error") {
 		t.Errorf("остановка записана отказом: журнал %q", got)
 	}
-	if got := jobCount(t, name, "true"); got != beforeErr {
-		t.Errorf("остановка засчитана отказом: было %v, стало %v", beforeErr, got)
-	}
-	if got := jobCount(t, name, "false"); got != beforeOk {
-		t.Errorf("остановка засчитана успешным прогоном: было %v, стало %v", beforeOk, got)
-	}
 }

internal/entity/audio_record.go

@@ -0,0 +1,196 @@
+package entity
+
+import (
+	"time"
+
+	"git.vakhrushev.me/av/transcriber/internal/clock"
+)
+
+// Рубежи конвейера. Рубеж называет **достигнутое**, а не предстоящее: по нему
+// видно, что с записью уже сделано, и потому остановленная запись продолжает с
+// места остановки, а не с начала.
+//
+// Конечный рубеж зовётся `done`: доставка ответа отправителю в конвейер не
+// входит, и слово описывает пройденный конвейер, а не полученный человеком
+// текст.
+const (
+	StateUploaded    = "uploaded"
+	StateNormalized  = "normalized"
+	StateSubmitted   = "submitted"
+	StateTranscribed = "transcribed"
+	StateDone        = "done"
+)
+
+// Причины остановки. Прежние состояния `failed` и `dead` схлопнуты сюда: обе
+// восстанавливаются одинаково — снятием признака, — и различие между ними
+// перестало быть структурным.
+const (
+	// HaltReasonStepFailed — шаг рассудил об этой записи окончательно.
+	HaltReasonStepFailed = "step_failed"
+	// HaltReasonAttempts — мы повторяли и перестали.
+	HaltReasonAttempts = "attempts_exhausted"
+	// HaltReasonStuck — запись простояла в рубеже дольше предела.
+	HaltReasonStuck = "stuck"
+)
+
+const (
+	SourceUnknown  = "unknown"
+	SourceApi      = "api"
+	SourceTelegram = "telegram"
+)
+
+// AudioRecord — аудиозапись, центральная сущность сервиса.
+//
+// Приложения к ней — файлы, тексты, структура реплик, темы, журнал событий и
+// попытка распознавания — живут своими строками и адресуются ссылками. Поля
+// очереди соседствуют с доменом, но не с содержимым: расшифровка лежит строкой
+// `texts`, и чтение очереди её не тянет.
+type AudioRecord struct {
+	Id string
+	// OwnerID — учётная запись, от имени которой запись принята. Пуст у записей
+	// из Telegram: связи чата с учётной записью сервис не ведёт. Назначается
+	// один раз, при приёме, и конвейером не меняется.
+	OwnerID *string
+	Source  string
+
+	// Title и Brief читаются вместе со списком, сотней штук разом, и потому
+	// лежат колонками записи, а не строками `texts`.
+	Title *string
+	Brief *string
+
+	State string
+	// StateEnteredAt ставится только сменой рубежа и возвратом записи в работу.
+	// Откладывание опроса его не двигает — иначе застревание в чужой операции
+	// не наступало бы никогда.
+	StateEnteredAt time.Time
+
+	// Остановка — признак, а не рубеж: `State` при ней не стирается.
+	HaltedAt   *time.Time
+	HaltReason *string
+	ErrorText  *string
+
+	// AcquisitionID — признак **этого** захвата, значение уникальное для каждого.
+	// Запись результата условна по нему, а не по занятости записи: захват,
+	// перевыданный другому — по протуханию срока или после снятия остановки
+	// человеком, — обязан обратить запись первого в отказ.
+	AcquisitionID    *string
+	AcquireExpiresAt *time.Time
+	DelayTime        *time.Time
+	// Attempts считает **отказы** и ограничивает повторы внутри шага. Время в
+	// рубеже мерит StateEnteredAt: одно число не справлялось ни с одной из двух
+	// обязанностей.
+	Attempts int
+
+	// Ссылки на файлы живут порознь и не переставляются: исходник остаётся
+	// доступным после того, как запись прошла конвейер.
+	OriginalFileID   *string
+	NormalizedFileID *string
+
+	StructureID      *string
+	TranscriptTextID *string
+	LiteraryTextID   *string
+	RecognitionID    *string
+
+	TgChatId         *int64
+	TgReplyMessageId *int
+
+	CreatedAt time.Time
+	UpdatedAt time.Time
+}
+
+// AllStates — закрытый перечень рубежей для схемы хранилища.
+func AllStates() []string {
+	out := make([]string, 0, len(stages))
+	for _, s := range stages {
+		out = append(out, s.Name)
+	}
+	return out
+}
+
+// AllHaltReasons — закрытый перечень причин остановки для схемы хранилища.
+func AllHaltReasons() []string {
+	return []string{HaltReasonStepFailed, HaltReasonAttempts, HaltReasonStuck}
+}
+
+// MoveToState двигает запись на новый рубеж и чистит служебные поля прошлого.
+//
+// Время входа в рубеж ставится заново: с этой минуты идёт отсчёт застревания.
+// Число отказов обнуляется — шаг, дошедший до перехода, завершился без отказа, а
+// отказы считают именно отказавшие: иначе запись, прошедшая конвейер целиком,
+// накопила бы их поштучно и остановилась бы здоровой.
+func (r *AudioRecord) MoveToState(state string) {
+	now := clock.Now()
+	r.State = state
+	r.StateEnteredAt = now
+	r.DelayTime = nil
+	r.AcquisitionID = nil
+	r.AcquireExpiresAt = nil
+	r.Attempts = 0
+	r.UpdatedAt = now
+}
+
+// Postpone откладывает работу над записью: ставит паузу и снимает захват.
+//
+// Переходом это не является и потому не трогает ни рубеж, ни время входа в
+// него. Число отказов обнуляется по прежнему доводу — ожидание чужой операции
+// отказом не является.
+//
+// Прежде шаг опроса звал переход с **тем же** состоянием, и мнимость этого
+// перехода обнуляла сторожа. Без разделения время входа в рубеж сбрасывалось бы
+// на каждом опросе и повторило бы ровно тот промах, ради которого заводится.
+func (r *AudioRecord) Postpone(until time.Time) {
+	r.DelayTime = &until
+	r.AcquisitionID = nil
+	r.AcquireExpiresAt = nil
+	r.Attempts = 0
+	r.UpdatedAt = clock.Now()
+}
+
+// RetryAfter освобождает отказавшую запись для повтора: захват снимается, пауза
+// ставится, а число отказов сохраняется — по нему растёт пауза и наступает
+// предел.
+func (r *AudioRecord) RetryAfter(delay time.Time) {
+	r.AcquisitionID = nil
+	r.AcquireExpiresAt = nil
+	r.DelayTime = &delay
+	r.UpdatedAt = clock.Now()
+}
+
+// Halt останавливает запись признаком, сохраняя достигнутый рубеж.
+//
+// Число отказов сохраняется: по нему видно, сколько раз пробовали. Захват
+// снимается — остановленная запись всё равно не выдаётся, а оставленный признак
+// захвата помешал бы первому же захвату после снятия остановки.
+func (r *AudioRecord) Halt(reason, errText string) {
+	now := clock.Now()
+	r.HaltedAt = &now
+	r.HaltReason = &reason
+	r.ErrorText = &errText
+	r.AcquisitionID = nil
+	r.AcquireExpiresAt = nil
+	r.DelayTime = nil
+	r.UpdatedAt = now
+}
+
+// Resume возвращает остановленную запись в работу с сохранённого рубежа.
+//
+// Сбрасываются все три сторожа. Время входа в рубеж — тоже, и это не
+// избыточность: запись, простоявшая остановленной дольше предела, иначе
+// останавливалась бы снова первым же захватом, и перезапуск не работал бы вовсе.
+func (r *AudioRecord) Resume() {
+	now := clock.Now()
+	r.HaltedAt = nil
+	r.HaltReason = nil
+	r.ErrorText = nil
+	r.Attempts = 0
+	r.DelayTime = nil
+	r.AcquisitionID = nil
+	r.AcquireExpiresAt = nil
+	r.StateEnteredAt = now
+	r.UpdatedAt = now
+}
+
+// IsHalted — стоит ли на записи признак остановки.
+func (r *AudioRecord) IsHalted() bool {
+	return r.HaltedAt != nil
+}

internal/entity/file.go

@@ -21,16 +21,23 @@ const (
 // дойдёт до обработчика — без строки в журнале приёма.
 const MaxRecordSize int64 = 8 << 30 // 8 ГиБ
 
-// File — одна физическая копия: исходник, результат конвертации и копия во
-// внешнем хранилище — три разные записи.
+// File — одна физическая копия записи. Их ровно две: принятая и приведённая к
+// рабочему формату. Копия во внешнем хранилище файлом записи не считается — она
+// существует только потому, что провайдер читает аудио по адресу, и её ключ
+// живёт в строке попытки распознавания.
 type File struct {
 	Id       string
 	Location string
-	// FileName — имя, под которым файл лежит: у местной копии это имя, заданное
-	// сервисом, у внешней — ключ объекта. Своего суффикса хранилище к заданному
-	// имени не дописывает: суффикс появляется только у имён, которые оно строит
-	// само из имени отправителя, а это умолчание не применяется.
-	FileName  string
-	Size      int64
-	CreatedAt time.Time
+	// FileName — имя, под которым файл лежит: имя задаёт сервис. Своего суффикса
+	// хранилище к заданному имени не дописывает: суффикс появляется только у
+	// имён, которые оно строит само из имени отправителя, а это умолчание не
+	// применяется.
+	FileName string
+	Size     int64
+	// Format — расширение без точки, приведённое к нижнему регистру. Наружу оно
+	// выходит только через метку метрики, приведённую к перечню известных.
+	Format string
+	// DurationMs — длительность записи, если её удалось прочитать.
+	DurationMs int64
+	CreatedAt  time.Time
 }

internal/entity/job.go

@@ -1,98 +0,0 @@
-package entity
-
-import (
-	"time"
-
-	"git.vakhrushev.me/av/transcriber/internal/clock"
-)
-
-type TranscribeJob struct {
-	Id    string
-	State string
-	// OwnerID — учётная запись, от имени которой запись принята. Пуст у записей
-	// из Telegram: связи чата с учётной записью сервис не ведёт. Назначается
-	// один раз, при приёме, и у записи, где он есть, больше не меняется.
-	OwnerID           *string
-	Source            string
-	FileID            *string
-	ErrorText         *string
-	AcquisitionID     *string
-	AcquireTime       *time.Time
-	DelayTime         *time.Time
-	Attempts          int     // Число попыток: растёт при захвате, обнуляется на шаге без отказа
-	RecognitionOpID   *string // ID операции распознавания в Yandex Cloud
-	TranscriptionText *string // Результат распознавания
-	TgChatId          *int64  // Telegram: в какой чат отправить результат распознавания
-	TgReplyMessageId  *int    // Telegram: с каким сообщением связать результат распознавания
-	CreatedAt         time.Time
-	UpdatedAt         time.Time
-}
-
-const (
-	StateCreated    = "created"
-	StateConverted  = "converted"
-	StateTranscribe = "transcribe"
-	StateDone       = "done"
-	StateFailed     = "failed"
-	// StateDead — задача, которую мы повторяли и перестали. От `failed` она
-	// отличается тем, чей это приговор: в `failed` задачу переводит шаг,
-	// рассудивший об этой записи окончательно, а сюда она уходит без такого
-	// суждения. Ни один шаг конвейера в неё не переводит сам.
-	StateDead = "dead"
-)
-
-const (
-	SourceUnknown  = "unknown"
-	SourceApi      = "api"
-	SourceTelegram = "telegram"
-)
-
-// Переводит задачу в новое состояние, при этом очищает все
-// служебные поля предыдущего состояния, как-то время задержки, информацию о воркере и тд
-func (j *TranscribeJob) MoveToState(state string) {
-	j.State = state
-	j.DelayTime = nil
-	j.AcquisitionID = nil
-	j.AcquireTime = nil
-	// Шаг, дошедший до перехода, завершился без отказа, а попытки считают
-	// именно отказавшие: иначе задача, прошедшая конвейер целиком, накопила бы
-	// их поштучно и умерла бы здоровой.
-	j.Attempts = 0
-	j.UpdatedAt = clock.Now()
-}
-
-func (j *TranscribeJob) MoveToStateAndDelay(state string, delay *time.Time) {
-	j.MoveToState(state)
-	j.DelayTime = delay
-	j.UpdatedAt = clock.Now()
-}
-
-func (j *TranscribeJob) Done(transcriptionText string) {
-	j.MoveToState(StateDone)
-	j.TranscriptionText = &transcriptionText
-}
-
-func (j *TranscribeJob) Fail(errText string) {
-	j.MoveToState(StateFailed)
-	j.ErrorText = &errText
-}
-
-// RetryAfter освобождает отказавшую задачу для повтора: захват снимается,
-// пауза ставится, а число попыток сохраняется — по нему растёт пауза и
-// наступает предел.
-func (j *TranscribeJob) RetryAfter(delay time.Time) {
-	j.AcquisitionID = nil
-	j.AcquireTime = nil
-	j.DelayTime = &delay
-	j.UpdatedAt = clock.Now()
-}
-
-// Die переводит задачу, исчерпавшую попытки, в состояние «мертва». Число
-// попыток при этом сохраняется: по нему видно, сколько раз мы пробовали, а
-// возвращает задачу в работу владелец правкой состояния.
-func (j *TranscribeJob) Die(errText string) {
-	attempts := j.Attempts
-	j.MoveToState(StateDead)
-	j.Attempts = attempts
-	j.ErrorText = &errText
-}

internal/entity/recognition.go

@@ -1,6 +1,8 @@
 package entity
 
-// RecognitionStatus представляет статус операции транскрипции
+import "time"
+
+// RecognitionStatus представляет статус операции распознавания у провайдера.
 type RecognitionStatus int
 
 const (
@@ -26,7 +28,7 @@ func (s RecognitionStatus) String() string {
 	}
 }
 
-// RecognitionResult представляет результат операции транскрипции
+// RecognitionResult представляет исход опроса операции распознавания.
 type RecognitionResult struct {
 	Status RecognitionStatus
 	Error  string // Текст ошибки (заполняется при StatusFailed)
@@ -76,3 +78,43 @@ func (r *RecognitionResult) GetError() string {
 	}
 	return ""
 }
+
+// Recognition — попытка распознавания у внешнего провайдера.
+//
+// Всё провайдерское живёт здесь, а не колонками записи: идентификатор операции —
+// самое провайдерское, что есть в модели, а копия аудио во внешнем хранилище
+// существует только потому, что сегодняшний провайдер читает запись по адресу.
+// Другой провайдер её не потребует, и смена провайдера не трогает доменную
+// сущность вовсе.
+//
+// Сырой ответ хранится вложением, а не колонкой этой строки: шаг опроса читает
+// её раз в несколько секунд, а хранилище читает запись целиком — ответ на
+// многочасовую запись ехал бы в память при каждом опросе. Хранится он потому,
+// что результат операции у провайдера не переспрашивается.
+type Recognition struct {
+	Id       string
+	RecordID string
+	Provider string
+	Model    string
+	// ExternalID — идентификатор операции у провайдера. Заводится **до**
+	// обращения к нему: окно между ответом провайдера и записью идентификатора —
+	// то место, где теряется оплаченное.
+	ExternalID string
+	// SourceURI — адрес, по которому провайдер читает аудио.
+	SourceURI  string
+	StartedAt  *time.Time
+	FinishedAt *time.Time
+}
+
+// RecognitionOutcome — доменный результат распознавания, каким его отдаёт
+// адаптер. Формата провайдера здесь нет: разбор потока — обязанность адаптера, и
+// ни один шаг конвейера не знает, каким потоком и какими полями провайдер
+// отвечает.
+type RecognitionOutcome struct {
+	// Replicas — реплики со временем от начала записи.
+	Replicas []Replica
+	// PlainText — плоский текст расшифровки.
+	PlainText string
+	// Raw — ответ провайдера целиком, как он пришёл, на хранение вложением.
+	Raw []byte
+}

internal/entity/record_event.go

@@ -0,0 +1,50 @@
+package entity
+
+// Источник события журнала записи.
+const (
+	// EventOriginPipeline — событие произвёл шаг конвейера.
+	EventOriginPipeline = "pipeline"
+	// EventOriginHuman — событие произвёл человек: перезапуск виден в журнале с
+	// указанием, кто его сделал.
+	EventOriginHuman = "human"
+)
+
+// Исход события.
+const (
+	EventOutcomeDone    = "done"
+	EventOutcomeFailed  = "failed"
+	EventOutcomeHalted  = "halted"
+	EventOutcomeResumed = "resumed"
+)
+
+// AllEventOrigins — закрытый перечень источников для схемы хранилища.
+func AllEventOrigins() []string {
+	return []string{EventOriginPipeline, EventOriginHuman}
+}
+
+// AllEventOutcomes — закрытый перечень исходов для схемы хранилища.
+func AllEventOutcomes() []string {
+	return []string{EventOutcomeDone, EventOutcomeFailed, EventOutcomeHalted, EventOutcomeResumed}
+}
+
+// RecordEvent — строка журнала событий одной записи.
+//
+// Пишется на смену рубежа, на остановку и на снятие остановки — не на каждое
+// откладывание опроса: часовая запись дала бы сотни строк ни о чём. Ни один шаг
+// конвейера этот журнал не читает, чтобы решить, что делать дальше: решение
+// принимается по рубежу записи, и второй источник решения разошёлся бы с первым
+// молча.
+//
+// Содержимое записи сюда не попадает — инвариант приватности действует здесь
+// наравне с журналом сервиса. Поле текста отказа зовётся `OutcomeText`, а не
+// `error_text`: последнее имя названо поимённо инвариантом о секрете, и две
+// колонки с этим именем сделали бы инвариант двусмысленным.
+type RecordEvent struct {
+	Id          string
+	RecordID    string
+	Origin      string
+	Step        string
+	Outcome     string
+	OutcomeText string
+	DurationMs  int64
+}

internal/entity/retired_states.go

@@ -0,0 +1,22 @@
+package entity
+
+// Состояния прежней модели. **Частью модели они не являются** и в перечень
+// рубежей не входят: цепочку рубежей объявляет `stage.go`, а закрытый перечень
+// для схемы — `AllStates()`.
+//
+// Живут они здесь по одной причине: шаг схемы `202608110001_init.go` заводил
+// прежнюю коллекцию задач этими значениями, а **применённый шаг схемы не
+// переписывается** — хранилище считает применённое по имени файла, и правка
+// сделала бы его другим шагом под прежним именем. Шаг ссылается на эти
+// константы, значит они обязаны существовать, пока существует он.
+//
+// Коллекцию, которую он заводил, удаляет шаг `202608140002`. Ни один живой путь
+// сервиса этих значений не читает и не пишет; `StateDone` в этом списке нет —
+// то же слово осталось именем конечного рубежа новой модели.
+const (
+	StateCreated    = "created"
+	StateConverted  = "converted"
+	StateTranscribe = "transcribe"
+	StateFailed     = "failed"
+	StateDead       = "dead"
+)

internal/entity/stage.go

@@ -0,0 +1,97 @@
+package entity
+
+import "time"
+
+// Work — чью работу ждёт запись, стоя на рубеже. От этого зависит предел
+// простоя: своя работа мерится одним числом, ожидание чужой операции — другим.
+// Граница проходит по исполнителю, а не по рубежу: число на каждый рубеж
+// назвало бы разными вещи, различающиеся только им.
+type Work int
+
+const (
+	// WorkOwn — работу делаем мы сами.
+	WorkOwn Work = iota
+	// WorkForeign — ждём операцию внешнего сервиса.
+	WorkForeign
+)
+
+// Stage — объявление рубежа одним местом.
+//
+// Из этого перечня выводятся все потребители: выбор следующего шага, отбор
+// захвата, срок протухания захвата и предел простоя. Перечислять рубежи порознь
+// в каждом потребителе нельзя: рубеж, забытый в отборе захвата, не выдаётся ни
+// одному воркеру никогда, а пустой прогон по инварианту проекта не пишется в
+// журнал и не считается в метрику — запись встала бы без единого следа.
+type Stage struct {
+	Name string
+	// Work — чью работу ждём, стоя на этом рубеже.
+	Work Work
+	// AcquireTimeout — срок протухания захвата. Едет с рубежом, а не с воркером:
+	// воркер не привязан к шагу и не знает заранее, что вытянет.
+	AcquireTimeout time.Duration
+	// Terminal — рубеж, из которого запись в работу не берут. Такой рубеж не
+	// подпадает и под предел простоя: стоять в нём запись будет вечно по
+	// построению.
+	Terminal bool
+}
+
+// Сроки захвата. Каждый не меньше того, что его шаг может занять на самом
+// длинном допустимом входе: расчётный потолок записи — шесть часов, и приведение
+// такой записи идёт дольше часа по построению.
+const (
+	normalizeAcquireTimeout = 8 * time.Hour
+	submitAcquireTimeout    = 8 * time.Hour
+	pollAcquireTimeout      = time.Hour
+	finishAcquireTimeout    = time.Hour
+)
+
+// stages — цепочка рубежей в порядке прохождения.
+var stages = []Stage{
+	{Name: StateUploaded, Work: WorkOwn, AcquireTimeout: normalizeAcquireTimeout},
+	{Name: StateNormalized, Work: WorkOwn, AcquireTimeout: submitAcquireTimeout},
+	{Name: StateSubmitted, Work: WorkForeign, AcquireTimeout: pollAcquireTimeout},
+	{Name: StateTranscribed, Work: WorkOwn, AcquireTimeout: finishAcquireTimeout},
+	{Name: StateDone, Terminal: true},
+}
+
+// WorkingStages — рубежи, с которых запись берут в работу.
+func WorkingStages() []Stage {
+	out := make([]Stage, 0, len(stages))
+	for _, s := range stages {
+		if !s.Terminal {
+			out = append(out, s)
+		}
+	}
+	return out
+}
+
+// StageByName находит рубеж по имени. Второе значение ложно у рубежа, которого
+// в цепочке нет: запись с таким рубежом до шага не доходит.
+func StageByName(name string) (Stage, bool) {
+	for _, s := range stages {
+		if s.Name == name {
+			return s, true
+		}
+	}
+	return Stage{}, false
+}
+
+// StuckLimits — пределы простоя, приходящие из настроек.
+type StuckLimits struct {
+	// Own — предел на своей работе.
+	Own time.Duration
+	// Foreign — предел на ожидании чужой операции.
+	Foreign time.Duration
+}
+
+// Limit — предел простоя для этого рубежа. У конечного рубежа предела нет:
+// запись стоит в нём вечно по построению.
+func (s Stage) Limit(limits StuckLimits) (time.Duration, bool) {
+	if s.Terminal {
+		return 0, false
+	}
+	if s.Work == WorkForeign {
+		return limits.Foreign, true
+	}
+	return limits.Own, true
+}

internal/entity/structure.go

@@ -0,0 +1,28 @@
+package entity
+
+// StructureVersion — версия вида структуры реплик. Разбор сохранённого ответа
+// провайдера изменится раньше, чем архив пересчитают, и по номеру видно, какой
+// разбор её построил.
+const StructureVersion = 1
+
+// Replica — одна реплика с временем от начала записи.
+//
+// Говорящий сегодня не размечается: связь реплики с разбором говорящего у
+// провайдера не выяснена. Поле заведено, потому что структура строится из
+// сохранённого ответа и пересчитается без повторной оплаты, когда связь
+// выяснится.
+type Replica struct {
+	StartMs int64  `json:"start_ms"`
+	EndMs   int64  `json:"end_ms"`
+	Speaker string `json:"speaker,omitempty"`
+	Text    string `json:"text"`
+}
+
+// Structure — реплики записи со временем. Лежит своей строкой, пара «запись и
+// версия разбора» уникальна.
+type Structure struct {
+	Id       string
+	RecordID string
+	Version  int
+	Replicas []Replica
+}

internal/entity/text.go

@@ -0,0 +1,28 @@
+package entity
+
+// Виды текста записи. Расшифровка и вычитанный текст читаются по открытию одной
+// записи и лежат строками `texts`, а не колонками: колонкой на каждый вид схема
+// росла бы с каждым новым видом, а необратимый шаг схемы платится за каждую
+// такую колонку отдельно.
+const (
+	// TextKindTranscript — сырая расшифровка, как её отдал распознаватель.
+	TextKindTranscript = "transcript"
+	// TextKindLiterary — вычитанный текст. Его считает отдельная задача; здесь
+	// заведено только место, куда он ляжет.
+	TextKindLiterary = "literary"
+)
+
+// AllTextKinds — закрытый перечень видов текста для схемы хранилища.
+func AllTextKinds() []string {
+	return []string{TextKindTranscript, TextKindLiterary}
+}
+
+// Text — один вид текста одной записи. Пара «запись и вид» уникальна: повтор
+// прерванного шага иначе завёл бы второй комплект строк, и вопрос «какой текст
+// отдавать человеку» стал бы вопросом порядка записи, а не состояния.
+type Text struct {
+	Id       string
+	RecordID string
+	Kind     string
+	Contents string
+}

internal/entity/topic.go

@@ -0,0 +1,22 @@
+package entity
+
+// MaxTopicsPerRecord — потолок числа тем у одной записи. Без него часовой
+// разговор даёт два десятка тем, и словарь распухает за неделю; это же число
+// уезжает в запрос к языковой модели.
+const MaxTopicsPerRecord = 5
+
+// Topic — тема из словаря одного человека. Пара «владелец и название»
+// уникальна: словарь тем свой у каждого.
+//
+// Коллекцией, а не набором строк в записи, потому что перечень тем человека
+// нужен целиком перед каждым обращением к модели, а собрать его из наборов строк
+// можно только перебором всех его записей.
+//
+// Ни один шаг этой работы тем не пишет и не читает: место заведено вперёд, чтобы
+// задача, считающая темы языковой моделью, не платила вторым необратимым шагом
+// схемы.
+type Topic struct {
+	Id      string
+	OwnerID string
+	Name    string
+}

internal/metrics/metrics.go

@@ -6,12 +6,17 @@ import (
 )
 
 var (
+	// Работа конвейера с разрезом по **рубежу**, с которого взята запись, а не по
+	// имени потока. Воркеры одинаковы, и имя потока перестало что-либо значить;
+	// а счётчик отказов — единственный сигнал, по которому владелец сервиса
+	// замечает поломку, и без разреза по шагу «падает приведение» и «падает
+	// распознавание» стали бы неразличимы.
 	WorkerJobCounter = promauto.NewCounterVec(
 		prometheus.CounterOpts{
 			Name: "transcriber_worker_job_count",
-			Help: "Count of jobs handled by each worker",
+			Help: "Count of pipeline steps by the stage a record was taken from",
 		},
-		[]string{"name", "error"},
+		[]string{"stage", "error"},
 	)
 
 	// Размер принятых на обработку файлов (в байтах)

internal/service/find_job_test.go

@@ -5,67 +5,71 @@ import (
 	"fmt"
 	"log/slog"
 	"testing"
-	"time"
 
 	"git.vakhrushev.me/av/transcriber/internal/contract"
 	"git.vakhrushev.me/av/transcriber/internal/entity"
 )
 
 // Путь признака «работы нет» состоит из двух звеньев: репозиторий рождает
-// «подходящей задачи не нашлось», сервис переводит это в «работы нет», и уже
-// его читает воркер. Проверки воркера подменяют работу целиком и второе звено
-// не видят — без этого файла правку в сервисе принимал бы только линтер, а он
-// судит форму записи, а не то, узнаётся ли признак на самом деле.
+// «пригодной записи не нашлось», сервис переводит это в «работы нет», и уже его
+// читает воркер. Проверки воркера подменяют работу целиком и второе звено не
+// видят — без этого файла правку в сервисе принимал бы только линтер, а он судит
+// форму записи, а не то, узнаётся ли признак на самом деле.
 
-// stubJobRepo отдаёт заданную ошибку на запрос задачи. Прочих методов запроса
-// задачи проверки этого файла не зовут.
-type stubJobRepo struct {
+// stubRecordRepo отдаёт заданную ошибку на запрос записи. Прочих методов
+// проверки этого файла не зовут.
+type stubRecordRepo struct {
 	err error
 }
 
-func (r *stubJobRepo) Create(*entity.TranscribeJob) error       { return nil }
-func (r *stubJobRepo) Save(*entity.TranscribeJob, string) error { return nil }
+func (r *stubRecordRepo) Create(*entity.AudioRecord) error       { return nil }
+func (r *stubRecordRepo) Save(*entity.AudioRecord, string) error { return nil }
 
-func (r *stubJobRepo) GetByID(string, string) (*entity.TranscribeJob, error) {
+func (r *stubRecordRepo) GetByID(string, string) (*entity.AudioRecord, error) {
 	return nil, errors.New("не зовётся этими проверками")
 }
 
-func (r *stubJobRepo) FindAndAcquire(string, string, time.Time) (*entity.TranscribeJob, error) {
+func (r *stubRecordRepo) Get(string) (*entity.AudioRecord, error) {
+	return nil, errors.New("не зовётся этими проверками")
+}
+
+func (r *stubRecordRepo) FindAndAcquire([]entity.Stage) (*contract.AcquiredRecord, error) {
 	return nil, r.err
 }
 
-func serviceWithRepo(repo contract.TranscriptJobRepository) *TranscribeService {
-	logger := slog.New(slog.DiscardHandler)
-	return NewTranscribeService(repo, nil, nil, nil, nil, nil, logger)
+func serviceWithRepo(repo contract.AudioRecordRepository) *TranscribeService {
+	return NewTranscribeService(
+		Repositories{Records: repo},
+		nil, nil, nil, nil,
+		entity.StuckLimits{},
+		slog.New(slog.DiscardHandler),
+	)
 }
 
 // Репозиторий вправе добавить своему отказу пояснение — соседние ветки того же
 // метода уже оборачивают ошибки `%w` подряд. Пока признак узнавался приведением
 // типа, первая такая обёртка превратила бы пустой прогон в отказ: воркер начал
-// бы писать в журнал раз в секунду на каждом из трёх воркеров.
-func TestFindJobTranslatesWrappedNotFoundToNoop(t *testing.T) {
-	svc := serviceWithRepo(&stubJobRepo{
-		err: fmt.Errorf("find and acquire job: %w",
-			&contract.JobNotFoundError{State: "created", Message: "appropriate job not found"}),
+// бы писать в журнал раз в секунду на каждом воркере пула.
+func TestAcquireTranslatesWrappedNotFoundToNoop(t *testing.T) {
+	svc := serviceWithRepo(&stubRecordRepo{
+		err: fmt.Errorf("find and acquire record: %w",
+			&contract.JobNotFoundError{Message: "no record is ready for work"}),
 	})
 
-	_, _, err := svc.findJob("created", time.Minute)
+	_, _, err := svc.acquire()
 
 	var noop *contract.NoopJobError
 	if !errors.As(err, &noop) {
-		t.Fatalf("обёрнутое «задачи нет» не переведено в пустой прогон: получено %v", err)
-	}
-	if noop.State != "created" {
-		t.Errorf("состояние потеряно при переводе: %q", noop.State)
+		t.Fatalf("обёрнутое «работы нет» не переведено в пустой прогон: получено %v", err)
 	}
 }
 
 // Оборотная сторона: настоящий отказ хранилища пустым прогоном считаться не
-// должен, иначе задача молча крутилась бы в цикле без единой записи.
-func TestFindJobKeepsRealFailure(t *testing.T) {
-	svc := serviceWithRepo(&stubJobRepo{err: errors.New("database is gone")})
+// должен, иначе запись молча крутилась бы в цикле без единой записи в журнале.
+func TestAcquireKeepsRealFailure(t *testing.T) {
+	svc := serviceWithRepo(&stubRecordRepo{err: errors.New("database is gone")})
 
-	_, _, err := svc.findJob("created", time.Minute)
+	_, _, err := svc.acquire()
 
 	var noop *contract.NoopJobError
 	if errors.As(err, &noop) {

internal/service/metrics_test.go

@@ -0,0 +1,83 @@
+package service
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"git.vakhrushev.me/av/transcriber/internal/entity"
+)
+
+// Счёт работы конвейера живёт в шаге, а не в воркере: только шаг знает рубеж, с
+// которого взята запись, а воркеры пула одинаковы и именем ничего не говорят.
+
+// stageCount читает счётчик работы из общего реестра процесса. Судит реестр, а
+// не переменную пакета: метка, потерянная в точке употребления, переменную не
+// ломает, а на странице метрик видна.
+func stageCount(t *testing.T, stage, errLabel string) float64 {
+	t.Helper()
+
+	families, err := prometheus.DefaultGatherer.Gather()
+	require.NoError(t, err)
+
+	for _, mf := range families {
+		if mf.GetName() != "transcriber_worker_job_count" {
+			continue
+		}
+		for _, m := range mf.GetMetric() {
+			var gotStage, gotErr string
+			for _, label := range m.GetLabel() {
+				switch label.GetName() {
+				case "stage":
+					gotStage = label.GetValue()
+				case "error":
+					gotErr = label.GetValue()
+				}
+			}
+			if gotStage == stage && gotErr == errLabel {
+				return m.GetCounter().GetValue()
+			}
+		}
+	}
+	return 0
+}
+
+// Критерий приёмки 11. Отказ виден с разрезом по шагу: счётчик отказов —
+// единственный сигнал, по которому владелец сервиса замечает поломку, и без
+// метки рубежа «падает приведение» и «падает распознавание» стали бы
+// неразличимы.
+func TestFailureIsCountedWithStageLabel(t *testing.T) {
+	env := newPipelineEnv(t, &okMetaViewer{}, &okConverter{})
+
+	beforeOk := stageCount(t, entity.StateUploaded, "false")
+
+	record := newTelegramRecord(t, env)
+	require.NoError(t, env.service.RunStep(t.Context()))
+	require.Equal(t, entity.StateNormalized, readRecord(t, env, record.Id).State)
+
+	assert.InDelta(t, beforeOk+1, stageCount(t, entity.StateUploaded, "false"), 0,
+		"успешный шаг засчитан с меткой своего рубежа")
+
+	// Теперь тот же рубеж, но с отказом.
+	failing := newPipelineEnv(t, &okMetaViewer{}, &failingStepConverter{})
+	beforeErr := stageCount(t, entity.StateUploaded, "true")
+
+	newTelegramRecord(t, failing)
+	require.Error(t, failing.service.RunStep(t.Context()))
+
+	assert.InDelta(t, beforeErr+1, stageCount(t, entity.StateUploaded, "true"), 0,
+		"отказ засчитан с меткой того же рубежа")
+}
+
+// failingStepConverter отказывает **отказом шага**, а не приговором записи:
+// приговор счётчик отказов не растит, потому что шаг при нём отрабатывает.
+type failingStepConverter struct{}
+
+func (c *failingStepConverter) Convert(_ context.Context, _, dest string) error {
+	// Файл результата не создаётся вовсе — шаг отказывает на измерении копии.
+	return os.Remove(dest)
+}

internal/service/ownership_test.go

@@ -3,7 +3,6 @@ package service
 import (
 	"strings"
 	"testing"
-	"time"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -16,7 +15,7 @@ import (
 // показывать, а не кому её считать. Сужение остановило бы расшифровку записей
 // бота вовсе, а записи остальных поставило бы в зависимость от того, кто первым
 // завёл учётную запись.
-func TestWorkerTakesJobsOfEveryOwner(t *testing.T) {
+func TestWorkerTakesRecordsOfEveryOwner(t *testing.T) {
 	env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
 
 	first, err := env.service.CreateJobFromApi(t.Context(),
@@ -28,42 +27,48 @@ func TestWorkerTakesJobsOfEveryOwner(t *testing.T) {
 	require.NoError(t, err)
 
 	// Третья пришла ботом, и владельца у неё нет вовсе.
-	third := newTelegramJob(t, env)
+	third := newTelegramRecord(t, env)
 
-	// Срок протухания в прошлом: захваченная задача остаётся за держателем, и
-	// следующий вызов берёт следующую, а не ту же самую.
+	// Захваченная запись остаётся за держателем, и следующий вызов берёт
+	// следующую, а не ту же самую.
 	taken := map[string]bool{}
-	for _, holder := range []string{"one", "two", "three"} {
-		job, err := env.jobRepo.FindAndAcquire(entity.StateCreated, holder, time.Now().Add(-time.Hour))
-		require.NoError(t, err, "воркер берёт задачи подряд, владельцем не сужаясь")
-		taken[job.Id] = true
+	for range 3 {
+		acquired, err := env.recordRepo.FindAndAcquire(entity.WorkingStages())
+		require.NoError(t, err, "воркер берёт записи подряд, владельцем не сужаясь")
+		taken[acquired.ID] = true
 	}
 
-	assert.True(t, taken[first.Id], "задача первого владельца досталась воркеру")
+	assert.True(t, taken[first.Id], "запись первого владельца досталась воркеру")
 	assert.True(t, taken[second.Id], "и второго")
-	assert.True(t, taken[third.Id], "и задача без владельца")
+	assert.True(t, taken[third.Id], "и запись без владельца")
 
-	_, err = env.jobRepo.FindAndAcquire(entity.StateCreated, "next", time.Now().Add(-time.Hour))
+	_, err = env.recordRepo.FindAndAcquire(entity.WorkingStages())
 	var missing *contract.JobNotFoundError
-	assert.ErrorAs(t, err, &missing, "больше в этом состоянии никого")
+	assert.ErrorAs(t, err, &missing, "больше пригодных к работе записей нет")
 }
 
-// Захват читает владельца: снимок задачи, в котором он всегда пуст, был бы
-// ловушкой для первого же шага, начавшего сохранять задачу целиком, — и сегодня
-// уже ломал бы файл, который шаг заводит.
-func TestAcquireCarriesOwner(t *testing.T) {
+// Захват отдаёт идентификатор и признак своего захвата — не перечень колонок.
+// Колонки шаг читает сам: иначе всякая новая колонка записи попадала бы под
+// инвариант проекта о колонках очереди.
+func TestAcquireReturnsIdentifierAndHolder(t *testing.T) {
 	env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
 
 	owner := newOwner(t, env.app)
-	job, err := env.service.CreateJobFromApi(t.Context(), strings.NewReader("запись"), "one.mp3", owner)
+	record, err := env.service.CreateJobFromApi(t.Context(), strings.NewReader("запись"), "one.mp3", owner)
 	require.NoError(t, err)
 
-	acquired, err := env.jobRepo.FindAndAcquire(entity.StateCreated, "holder", time.Now().Add(-time.Hour))
+	acquired, err := env.recordRepo.FindAndAcquire(entity.WorkingStages())
 	require.NoError(t, err)
-	require.Equal(t, job.Id, acquired.Id)
 
-	require.NotNil(t, acquired.OwnerID, "владелец приехал из захвата")
-	assert.Equal(t, owner, *acquired.OwnerID)
+	assert.Equal(t, record.Id, acquired.ID, "захват назвал запись")
+	assert.NotEmpty(t, acquired.Holder, "и признак своего захвата")
+
+	// Колонки читаются отдельным чтением, и владелец среди них.
+	read := readRecord(t, env, record.Id)
+	require.NotNil(t, read.OwnerID)
+	assert.Equal(t, owner, *read.OwnerID)
+	assert.Equal(t, acquired.Holder, *read.AcquisitionID, "признак захвата записан в саму запись")
+	require.NotNil(t, read.AcquireExpiresAt, "срок протухания приехал с рубежом")
 }
 
 // Шаг конвейера владельца не затирает: сохранение кладёт только то, чем
@@ -72,34 +77,54 @@ func TestPipelineStepKeepsOwner(t *testing.T) {
 	env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
 
 	owner := newOwner(t, env.app)
-	job, err := env.service.CreateJobFromApi(t.Context(), strings.NewReader("запись"), "one.mp3", owner)
+	record, err := env.service.CreateJobFromApi(t.Context(), strings.NewReader("запись"), "one.mp3", owner)
 	require.NoError(t, err)
 
-	// Отказ конвертации — приговор записи: шаг переводит задачу в `failed` и
-	// сохраняет её. Это сохранение владельца тронуть не должно.
-	require.NoError(t, env.service.FindAndRunConversionJob(t.Context()))
+	// Отказ приведения — приговор записи: шаг останавливает её и сохраняет. Это
+	// сохранение владельца тронуть не должно.
+	require.NoError(t, env.service.RunStep(t.Context()))
 
-	after, err := readJob(env.app, job.Id)
-	require.NoError(t, err)
-	require.Equal(t, entity.StateFailed, after.State, "шаг записал свой приговор")
+	after := readRecord(t, env, record.Id)
+	require.True(t, after.IsHalted(), "шаг записал свой приговор")
 	require.NotNil(t, after.OwnerID, "владелец пережил шаг")
 	assert.Equal(t, owner, *after.OwnerID)
 }
 
-// Приём из веба без владельца задачи не заводит. Обязательность держит здесь
+// Приём из веба без владельца записи не заводит. Обязательность держит здесь
 // код, а не схема: колонка допускает пустое значение ради записей бота.
 func TestCreateJobFromApiRequiresOwner(t *testing.T) {
 	env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
 
 	_, err := env.service.CreateJobFromApi(t.Context(), strings.NewReader("запись"), "one.mp3", "")
-
 	require.ErrorIs(t, err, contract.ErrOwnerRequired)
+}
 
-	records, err := env.app.FindAllRecords("transcribe_jobs")
+// Чужая запись, ничья и несуществующая отвечают одним и тем же: по разнице
+// ответов иначе перебирается список заведённых записей.
+func TestGetByIDHidesForeignRecords(t *testing.T) {
+	env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
+
+	owner := newOwner(t, env.app)
+	stranger := newOwner(t, env.app)
+
+	record, err := env.service.CreateJobFromApi(t.Context(), strings.NewReader("запись"), "one.mp3", owner)
 	require.NoError(t, err)
-	assert.Empty(t, records, "задачи не заведено")
+
+	// Запись без владельца — принятая ботом.
+	orphan := newTelegramRecord(t, env)
+
+	var missing *contract.JobNotFoundError
 
-	files, err := env.app.FindAllRecords("files")
-	require.NoError(t, err)
-	assert.Empty(t, files, "и файла тоже: отказ наступает раньше укладки")
+	_, err = env.recordRepo.GetByID(record.Id, stranger)
+	require.ErrorAs(t, err, &missing, "чужая запись неотличима от несуществующей")
+
+	_, err = env.recordRepo.GetByID(orphan.Id, stranger)
+	require.ErrorAs(t, err, &missing, "ничья запись не достаётся никому")
+
+	_, err = env.recordRepo.GetByID(record.Id, "")
+	require.ErrorAs(t, err, &missing, "пустой владелец не совпадает ни с чем")
+
+	own, err := env.recordRepo.GetByID(record.Id, owner)
+	require.NoError(t, err, "своя запись отдаётся")
+	assert.Equal(t, record.Id, own.Id)
 }

internal/service/pipeline_test.go

@@ -8,6 +8,7 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
+	"sync"
 	"testing"
 	"time"
 
@@ -24,10 +25,22 @@ import (
 	"git.vakhrushev.me/av/transcriber/internal/entity"
 )
 
-// Проверки конвейера идут против настоящего хранилища: захват, число попыток и
-// переход в «мертва» держатся на запросе, и подставной репозиторий проверял бы
+// Проверки конвейера идут против настоящего хранилища: захват, число отказов и
+// остановка держатся на запросе, и подставной репозиторий проверял бы
 // собственную заглушку, а не то, что делает база.
 
+// okConverter переливает исходник в результат — так это выглядит у настоящего
+// приведения к рабочему формату.
+type okConverter struct{}
+
+func (c *okConverter) Convert(_ context.Context, src, dest string) error {
+	content, err := os.ReadFile(src)
+	if err != nil {
+		return err
+	}
+	return os.WriteFile(dest, content, 0o600)
+}
+
 // failingConverter отказывает на каждой попытке.
 type failingConverter struct{}
 
@@ -47,26 +60,50 @@ func (m *failingMetaViewer) GetInfo(context.Context, string) (*contract.AudioInf
 	return nil, errors.New("запись не читается")
 }
 
-// recordingSender запоминает, что и куда отправлено.
+// recordingSender запоминает, что отправлено.
 type recordingSender struct {
+	mu       sync.Mutex
 	messages []string
 }
 
 func (s *recordingSender) Send(text string, chatId int64, replyMsgId *int) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
 	s.messages = append(s.messages, text)
 	return nil
 }
 
-type pipelineEnv struct {
-	app      core.App
-	service  *TranscribeService
-	jobRepo  *pbrepo.TranscriptJobRepository
-	fileRepo *pbrepo.FileRepository
-	sender   *recordingSender
+func (s *recordingSender) sent() []string {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return append([]string(nil), s.messages...)
 }
 
+type pipelineEnv struct {
+	app        core.App
+	service    *TranscribeService
+	repos      Repositories
+	recordRepo *pbrepo.AudioRecordRepository
+	fileRepo   *pbrepo.FileRepository
+	sender     *recordingSender
+}
+
+// testLimits — пределы простоя проверок. Числа боевые; проверка застревания
+// двигает не их, а время входа записи в рубеж: сторож меряет именно его.
+var testLimits = entity.StuckLimits{Own: time.Hour, Foreign: 24 * time.Hour}
+
 func newPipelineEnv(t *testing.T, metaviewer contract.AudioMetaViewer, converter contract.AudioFileConverter) *pipelineEnv {
 	t.Helper()
+	return newPipelineEnvWith(t, metaviewer, converter, &recognizer.MemoryAudioRecognizer{})
+}
+
+func newPipelineEnvWith(
+	t *testing.T,
+	metaviewer contract.AudioMetaViewer,
+	converter contract.AudioFileConverter,
+	rec contract.AudioRecognizer,
+) *pipelineEnv {
+	t.Helper()
 
 	app, err := pbrepo.New(t.TempDir())
 	require.NoError(t, err)
@@ -81,158 +118,410 @@ func newPipelineEnv(t *testing.T, metaviewer contract.AudioMetaViewer, converter
 	// нет.
 	pbrepo.BindPanelRules(app)
 
-	jobRepo := pbrepo.NewTranscriptJobRepository(app)
+	recordRepo := pbrepo.NewAudioRecordRepository(app)
 	fileRepo := pbrepo.NewFileRepository(app)
+	repos := Repositories{
+		Records:      recordRepo,
+		Files:        fileRepo,
+		Texts:        pbrepo.NewTextRepository(app),
+		Structures:   pbrepo.NewStructureRepository(app),
+		Recognitions: pbrepo.NewRecognitionRepository(app),
+		Events:       pbrepo.NewRecordEventRepository(app),
+	}
 	sender := &recordingSender{}
 
-	svc := NewTranscribeService(
-		jobRepo,
-		fileRepo,
-		metaviewer,
-		converter,
-		&recognizer.MemoryAudioRecognizer{},
-		sender,
-		slog.New(slog.DiscardHandler),
-	)
+	svc := NewTranscribeService(repos, metaviewer, converter, rec, sender, testLimits, slog.New(slog.DiscardHandler))
 
-	return &pipelineEnv{app: app, service: svc, jobRepo: jobRepo, fileRepo: fileRepo, sender: sender}
+	return &pipelineEnv{
+		app:        app,
+		service:    svc,
+		repos:      repos,
+		recordRepo: recordRepo,
+		fileRepo:   fileRepo,
+		sender:     sender,
+	}
 }
 
-// newTelegramJob заводит задачу с записью — так, как её завёл бы приём.
-func newTelegramJob(t *testing.T, env *pipelineEnv) *entity.TranscribeJob {
+// newTelegramRecord заводит запись — так, как её завёл бы приём из бота.
+func newTelegramRecord(t *testing.T, env *pipelineEnv) *entity.AudioRecord {
 	t.Helper()
 
-	chatId := int64(100)
-	job, err := env.service.CreateJobFromTelegram(t.Context(), strings.NewReader("запись"), "voice.ogg", chatId, 1)
+	record, err := env.service.CreateJobFromTelegram(t.Context(), strings.NewReader("запись"), "voice.ogg", 100, 1)
 	require.NoError(t, err)
-	return job
+	return record
 }
 
-// clearDelay снимает паузу, чтобы следующий прогон взял задачу сразу: проверка
-// судит счётчик попыток, а не то, умеет ли она ждать.
-func clearDelay(t *testing.T, env *pipelineEnv, jobID string) {
+// clearDelay снимает паузу, чтобы следующий прогон взял запись сразу.
+func clearDelay(t *testing.T, env *pipelineEnv, recordID string) {
 	t.Helper()
 
-	record, err := env.app.FindRecordById(migrations.JobsCollection, jobID)
+	record, err := env.app.FindRecordById(migrations.RecordsCollection, recordID)
 	require.NoError(t, err)
 	record.Set("delay_time", "")
 	require.NoError(t, env.app.Save(record))
 }
 
-// rotAcquisition отодвигает время захвата так, чтобы он протух: так это
-// выглядит, когда шаг оборвался вместе с процессом.
-func rotAcquisition(t *testing.T, env *pipelineEnv, jobID string) {
+// enteredStateAt отодвигает время входа записи в рубеж: так это выглядит, когда
+// запись простояла в нём дольше предела.
+func enteredStateAt(t *testing.T, env *pipelineEnv, recordID string, moment time.Time) {
 	t.Helper()
 
-	record, err := env.app.FindRecordById(migrations.JobsCollection, jobID)
+	record, err := env.app.FindRecordById(migrations.RecordsCollection, recordID)
 	require.NoError(t, err)
-	record.Set("acquire_time", types.NowDateTime().Add(-24*time.Hour))
+	record.Set("state_entered_at", types.DateTime{}.Add(0))
+	stamp, err := types.ParseDateTime(moment)
+	require.NoError(t, err)
+	record.Set("state_entered_at", stamp)
 	require.NoError(t, env.app.Save(record))
 }
 
-// Задача, падающая на каждой попытке, уходит в «мертва»: из выборки исчезает,
-// видна отбором по состоянию, а отправитель узнаёт о неудаче. Инвариант
-// «Принятая запись не теряется молча» допускает два исхода, и молчаливая смерть
-// не подходит ни под один.
-func TestJobDiesAfterAttemptLimit(t *testing.T) {
+// drain крутит конвейер, пока он двигает записи. Паузы опроса снимаются: они
+// проверяются отдельно, а здесь мешают дойти до конца.
+func drain(t *testing.T, env *pipelineEnv, recordID string) {
+	t.Helper()
+
+	for range 20 {
+		clearDelay(t, env, recordID)
+		err := env.service.RunStep(t.Context())
+		var noop *contract.NoopJobError
+		if errors.As(err, &noop) {
+			return
+		}
+		require.NoError(t, err)
+
+		after := readRecord(t, env, recordID)
+		if after.State == entity.StateDone || after.IsHalted() {
+			return
+		}
+	}
+	t.Fatal("конвейер не дошёл до исхода за отведённое число прогонов")
+}
+
+// readRecord читает запись мимо сужения владельцем.
+//
+// Читающий метод сервиса отдаёт запись только её владельцу, а проверки конвейера
+// смотрят записи, принятые ботом: владельца у таких нет вовсе. Проверке нужно не
+// право, а состояние записи после шага.
+func readRecord(t *testing.T, env *pipelineEnv, id string) *entity.AudioRecord {
+	t.Helper()
+
+	record, err := env.recordRepo.Get(id)
+	require.NoError(t, err)
+	return record
+}
+
+// Запись, отказывающая на каждой попытке, останавливается признаком: из выборки
+// исчезает, рубеж сохраняет, а отправитель узнаёт о неудаче. Инвариант «Принятая
+// запись не теряется молча» допускает два исхода, и молчаливая остановка не
+// подходит ни под один.
+func TestRecordHaltsAfterAttemptLimit(t *testing.T) {
 	env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
 
-	job := newTelegramJob(t, env)
+	record := newTelegramRecord(t, env)
 
-	// Отказ конвертации переводит задачу в `failed` сразу, поэтому предел
-	// попыток проверяем на шаге, который отказывает *не* приговором: подменяем
-	// его отказом источника метаданных внутри самого шага конвертации нельзя, и
-	// вместо этого гоняем захват без выполнения шага — так же, как это выглядит
-	// при гибели процесса.
-	for i := 0; i < maxAttempts; i++ {
-		_, err := env.jobRepo.FindAndAcquire(entity.StateCreated, "holder", time.Now().Add(time.Hour))
+	// Захват без выполнения шага — так это выглядит при гибели процесса: отказа
+	// шаг объявить не успевает, а попытка засчитана.
+	for range maxAttempts {
+		_, err := env.recordRepo.FindAndAcquire(entity.WorkingStages())
 		require.NoError(t, err)
+		expireAcquisition(t, env, record.Id)
 	}
-	rotAcquisition(t, env, job.Id)
 
-	// Следующий захват видит перебор и хоронит задачу.
-	err := env.service.FindAndRunConversionJob(t.Context())
+	err := env.service.RunStep(t.Context())
 
 	var noop *contract.NoopJobError
-	require.ErrorAs(t, err, &noop, "мёртвая задача шагу не отдаётся")
+	require.ErrorAs(t, err, &noop, "остановленная запись шагу не отдаётся")
 
-	after, err := readJob(env.app, job.Id)
-	require.NoError(t, err)
-	assert.Equal(t, entity.StateDead, after.State, "задача видна отбором по состоянию")
-	assert.Greater(t, after.Attempts, maxAttempts, "число попыток сохранено")
+	after := readRecord(t, env, record.Id)
+	assert.True(t, after.IsHalted(), "запись остановлена признаком")
+	require.NotNil(t, after.HaltReason)
+	assert.Equal(t, entity.HaltReasonAttempts, *after.HaltReason)
+	assert.Equal(t, entity.StateUploaded, after.State, "рубеж пережил остановку")
+	assert.Greater(t, after.Attempts, maxAttempts, "число отказов сохранено")
 
-	require.Len(t, env.sender.messages, 1, "отправитель узнал о неудаче")
-	assert.Contains(t, env.sender.messages[0], "попытки исчерпаны")
+	require.Len(t, env.sender.sent(), 1, "отправитель узнал о неудаче")
+	assert.Contains(t, env.sender.sent()[0], "попытки исчерпаны")
 
 	// И из выборки она исчезла.
-	_, err = env.jobRepo.FindAndAcquire(entity.StateCreated, "next", time.Now().Add(time.Hour))
+	_, err = env.recordRepo.FindAndAcquire(entity.WorkingStages())
 	var missing *contract.JobNotFoundError
 	assert.ErrorAs(t, err, &missing)
 }
 
-// Мёртвая задача возвращается в работу правкой состояния.
-func TestDeadJobReturnsAfterStateEdit(t *testing.T) {
-	env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
+// expireAcquisition отодвигает срок протухания захвата в прошлое: так это
+// выглядит, когда шаг оборвался вместе с процессом.
+func expireAcquisition(t *testing.T, env *pipelineEnv, recordID string) {
+	t.Helper()
 
-	job := newTelegramJob(t, env)
+	record, err := env.app.FindRecordById(migrations.RecordsCollection, recordID)
+	require.NoError(t, err)
+	record.Set("acquire_expires_at", types.NowDateTime().Add(-time.Hour))
+	require.NoError(t, env.app.Save(record))
+}
 
-	for i := 0; i < maxAttempts; i++ {
-		_, err := env.jobRepo.FindAndAcquire(entity.StateCreated, "holder", time.Now().Add(time.Hour))
+// Критерий приёмки 1. Остановленная на шаге запись перезапускается снятием
+// признака и продолжает с того рубежа, где стояла, — следующим идёт отправка на
+// распознавание, а не повторное приведение.
+func TestHaltedRecordResumesFromItsStage(t *testing.T) {
+	env := newPipelineEnv(t, &okMetaViewer{}, &okConverter{})
+
+	record := newTelegramRecord(t, env)
+
+	// Доводим до рубежа приведения и останавливаем на нём.
+	require.NoError(t, env.service.RunStep(t.Context()))
+	after := readRecord(t, env, record.Id)
+	require.Equal(t, entity.StateNormalized, after.State)
+
+	after.Halt(entity.HaltReasonStepFailed, "проверочная остановка")
+	require.NoError(t, env.recordRepo.Save(after, ""))
+
+	// Остановленная запись захвату не выдаётся.
+	_, err := env.recordRepo.FindAndAcquire(entity.WorkingStages())
+	var missing *contract.JobNotFoundError
+	require.ErrorAs(t, err, &missing, "остановленная запись из выборки исчезла")
+
+	// Снятие признака возвращает её в работу с сохранённого рубежа.
+	halted := readRecord(t, env, record.Id)
+	halted.Resume()
+	require.NoError(t, env.recordRepo.Save(halted, ""))
+
+	resumed := readRecord(t, env, record.Id)
+	assert.Equal(t, entity.StateNormalized, resumed.State, "рубеж сохранён")
+	assert.Equal(t, 0, resumed.Attempts, "отказы сброшены")
+
+	// Следующим идёт отправка на распознавание, а не повторное приведение.
+	require.NoError(t, env.service.RunStep(t.Context()))
+	next := readRecord(t, env, record.Id)
+	assert.Equal(t, entity.StateSubmitted, next.State, "продолжили с места остановки")
+	assert.NotNil(t, next.RecognitionID, "отправка состоялась")
+}
+
+// Критерий приёмки 2. У прошедшей конвейер записи ссылки на исходник и на
+// приведённую копию ведут на разные существующие файлы: прежде ссылка была одна,
+// и каждый шаг переставлял её на свой результат.
+func TestBothFileLinksSurvivePipeline(t *testing.T) {
+	env := newPipelineEnv(t, &okMetaViewer{}, &okConverter{})
+
+	record := newTelegramRecord(t, env)
+	drain(t, env, record.Id)
+
+	after := readRecord(t, env, record.Id)
+	require.Equal(t, entity.StateDone, after.State)
+
+	require.NotNil(t, after.OriginalFileID, "ссылка на принятую копию заполнена")
+	require.NotNil(t, after.NormalizedFileID, "ссылка на приведённую копию заполнена")
+	assert.NotEqual(t, *after.OriginalFileID, *after.NormalizedFileID, "копии разные")
+
+	for _, id := range []string{*after.OriginalFileID, *after.NormalizedFileID} {
+		reader, err := env.fileRepo.Open(id)
+		require.NoError(t, err, "обе копии открываются")
+		content, err := io.ReadAll(reader)
 		require.NoError(t, err)
+		assert.NotEmpty(t, content)
+		require.NoError(t, reader.Close())
 	}
-	require.Error(t, env.service.FindAndRunConversionJob(t.Context()))
-
-	record, err := env.app.FindRecordById(migrations.JobsCollection, job.Id)
-	require.NoError(t, err)
-	record.Set("state", entity.StateCreated)
-	require.NoError(t, env.app.Save(record))
-
-	again, err := env.jobRepo.FindAndAcquire(entity.StateCreated, "next", time.Now().Add(time.Hour))
-	require.NoError(t, err, "снятое состояние возвращает задачу в работу")
-	assert.Equal(t, job.Id, again.Id)
 }
 
-// Отказ шага не оставляет задачу захваченной до конца срока: захват снимается,
-// и задача ждёт нарастающую паузу. Иначе повтор наступал бы через восемь часов.
-func TestFailedStepSchedulesRetryWithGrowingDelay(t *testing.T) {
-	// Источник метаданных отказывает — это отказ шага, а не приговор записи.
-	env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
+// Критерий приёмки 3. Поведение записи не зависит от числа воркеров: при одном
+// и при нескольких она доходит до конечного рубежа.
+func TestOutcomeDoesNotDependOnWorkerCount(t *testing.T) {
+	for _, workers := range []int{1, 4} {
+		env := newPipelineEnv(t, &okMetaViewer{}, &okConverter{})
+		record := newTelegramRecord(t, env)
 
-	job := newTelegramJob(t, env)
+		for range 20 {
+			clearDelay(t, env, record.Id)
 
-	// Ссылку переставляем на запись без содержимого: шаг отказывает на получении
-	// рабочей копии — то есть отказом, а не приговором записи.
-	empty, err := env.fileRepo.CreateRemote("object-key", 1, "")
-	require.NoError(t, err)
+			var wg sync.WaitGroup
+			for range workers {
+				wg.Add(1)
+				go func() {
+					defer wg.Done()
+					// Исход прогона здесь не судится: воркеров несколько, и всем,
+					// кроме одного, работы не достаётся. Судится состояние записи.
+					if err := env.service.RunStep(t.Context()); err != nil {
+						t.Log(err)
+					}
+				}()
+			}
+			wg.Wait()
 
-	record, err := env.app.FindRecordById(migrations.JobsCollection, job.Id)
-	require.NoError(t, err)
-	record.Set("file", empty.Id)
-	require.NoError(t, env.app.Save(record))
+			if readRecord(t, env, record.Id).State == entity.StateDone {
+				break
+			}
+		}
 
-	// Первый отказ.
-	require.Error(t, env.service.FindAndRunConversionJob(t.Context()))
-
-	after, err := readJob(env.app, job.Id)
-	require.NoError(t, err)
-	require.Nil(t, after.AcquisitionID, "захват снят: задача пригодна к повтору")
-	require.NotNil(t, after.DelayTime, "пауза поставлена")
-
-	firstDelay := time.Until(*after.DelayTime)
-
-	// Второй отказ — с той же задачи, пауза снята вручную.
-	clearDelay(t, env, job.Id)
-	require.Error(t, env.service.FindAndRunConversionJob(t.Context()))
-
-	after, err = readJob(env.app, job.Id)
-	require.NoError(t, err)
-	require.NotNil(t, after.DelayTime)
-
-	secondDelay := time.Until(*after.DelayTime)
-	assert.Greater(t, secondDelay, firstDelay, "вторая пауза длиннее первой")
+		after := readRecord(t, env, record.Id)
+		assert.Equalf(t, entity.StateDone, after.State, "запись дошла до конца при %d воркерах", workers)
+		assert.Falsef(t, after.IsHalted(), "запись не остановлена при %d воркерах", workers)
+	}
 }
 
-// Пауза растёт с числом попыток и упирается в потолок.
+// Тот же критерий, вторая половина: нулевое число воркеров — законное значение.
+// Записи принимаются и не двигаются, и это режим, а не поломка.
+func TestZeroWorkersLeaveRecordUntouched(t *testing.T) {
+	env := newPipelineEnv(t, &okMetaViewer{}, &okConverter{})
+	record := newTelegramRecord(t, env)
+
+	// Пул нулевого размера ни одного прогона не делает — потому запись остаётся
+	// там, где её оставил приём.
+	after := readRecord(t, env, record.Id)
+	assert.Equal(t, entity.StateUploaded, after.State, "запись принята и стоит на первом рубеже")
+	assert.False(t, after.IsHalted(), "и не потеряна")
+	assert.Equal(t, record.Id, after.Id)
+}
+
+// Критерий приёмки 5, первая половина. Откладывание опроса не двигает время
+// входа в рубеж и не обнуляет отсчёт застревания: иначе запись, чью чужую
+// операцию опрашивают раз в несколько секунд, не достигла бы предела никогда.
+func TestPostponeKeepsStuckCountdown(t *testing.T) {
+	entered := time.Date(2026, 8, 14, 10, 0, 0, 0, time.UTC)
+	record := &entity.AudioRecord{State: entity.StateSubmitted, StateEnteredAt: entered}
+
+	for range 100 {
+		record.Postpone(time.Now().Add(5 * time.Second))
+	}
+
+	assert.Equal(t, entered, record.StateEnteredAt, "сотня откладываний не двигает отсчёт")
+	assert.Equal(t, entity.StateSubmitted, record.State, "и рубежа не трогает")
+	assert.Nil(t, record.AcquisitionID, "захват при этом снят")
+	assert.NotNil(t, record.DelayTime, "а пауза поставлена")
+}
+
+// Критерий приёмки 5, вторая половина. Запись, простоявшая в рубеже дольше
+// предела, останавливается признаком с причиной «застряла».
+func TestStuckRecordIsHalted(t *testing.T) {
+	env := newPipelineEnv(t, &okMetaViewer{}, &okConverter{})
+
+	record := newTelegramRecord(t, env)
+	enteredStateAt(t, env, record.Id, time.Now().Add(-2*testLimits.Own))
+
+	err := env.service.RunStep(t.Context())
+	var noop *contract.NoopJobError
+	require.ErrorAs(t, err, &noop, "застрявшая запись шагу не отдаётся")
+
+	after := readRecord(t, env, record.Id)
+	require.True(t, after.IsHalted())
+	require.NotNil(t, after.HaltReason)
+	assert.Equal(t, entity.HaltReasonStuck, *after.HaltReason, "причина названа")
+	assert.Equal(t, entity.StateUploaded, after.State, "рубеж сохранён")
+
+	require.Len(t, env.sender.sent(), 1, "отправитель узнал о неудаче")
+	assert.Contains(t, env.sender.sent()[0], "застряла")
+}
+
+// Конечный рубеж под предел простоя не подпадает: стоять в нём запись будет
+// вечно по построению, и сторож остановил бы всякую доведённую запись.
+func TestDoneRecordIsNeverStuck(t *testing.T) {
+	env := newPipelineEnv(t, &okMetaViewer{}, &okConverter{})
+
+	record := newTelegramRecord(t, env)
+	drain(t, env, record.Id)
+	enteredStateAt(t, env, record.Id, time.Now().Add(-10*24*time.Hour))
+
+	err := env.service.RunStep(t.Context())
+	var noop *contract.NoopJobError
+	require.ErrorAs(t, err, &noop, "доведённая запись в работу не берётся")
+
+	after := readRecord(t, env, record.Id)
+	assert.Equal(t, entity.StateDone, after.State)
+	assert.False(t, after.IsHalted(), "признака остановки у доведённой записи нет")
+}
+
+// Критерий приёмки 6. Держатель захвата отличим значением, а не занятостью
+// записи: шаг, чей захват достался другому, результата не пишет и отправителю
+// ничего не шлёт.
+func TestOnlyHolderWritesResult(t *testing.T) {
+	env := newPipelineEnv(t, &okMetaViewer{}, &okConverter{})
+
+	record := newTelegramRecord(t, env)
+
+	first, err := env.recordRepo.FindAndAcquire(entity.WorkingStages())
+	require.NoError(t, err)
+	require.Equal(t, record.Id, first.ID)
+
+	// Человек снял признак остановки — панель чистит признак захвата, — и запись
+	// достаётся другому воркеру.
+	expireAcquisition(t, env, record.Id)
+	second, err := env.recordRepo.FindAndAcquire(entity.WorkingStages())
+	require.NoError(t, err)
+	require.NotEqual(t, first.Holder, second.Holder, "признак нового захвата отличается")
+
+	// Первый доходит до записи результата и получает отказ.
+	stale := readRecord(t, env, record.Id)
+	stale.MoveToState(entity.StateNormalized)
+	err = env.recordRepo.Save(stale, first.Holder)
+
+	var lost *contract.LostAcquisitionError
+	require.ErrorAs(t, err, &lost, "потерявший захват не пишет")
+
+	after := readRecord(t, env, record.Id)
+	assert.Equal(t, entity.StateUploaded, after.State, "рубеж не сдвинут потерявшим захват")
+	assert.Empty(t, env.sender.sent(), "и отправителю от него ничего не ушло")
+}
+
+// Критерий приёмки 7. Всякий способ вывести запись из работы сообщает
+// отправителю: причин остановки больше одной, и обязанность у них общая.
+func TestEveryHaltReasonNotifiesSender(t *testing.T) {
+	reasons := []struct {
+		name string
+		halt func(t *testing.T, env *pipelineEnv, recordID string)
+	}{
+		{
+			name: "приговор шага",
+			halt: func(t *testing.T, env *pipelineEnv, recordID string) {
+				require.NoError(t, env.service.RunStep(t.Context()))
+			},
+		},
+		{
+			name: "застревание",
+			halt: func(t *testing.T, env *pipelineEnv, recordID string) {
+				enteredStateAt(t, env, recordID, time.Now().Add(-2*testLimits.Own))
+				var noop *contract.NoopJobError
+				require.ErrorAs(t, env.service.RunStep(t.Context()), &noop)
+			},
+		},
+	}
+
+	for _, reason := range reasons {
+		t.Run(reason.name, func(t *testing.T) {
+			env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
+			record := newTelegramRecord(t, env)
+
+			reason.halt(t, env, record.Id)
+
+			after := readRecord(t, env, record.Id)
+			require.True(t, after.IsHalted(), "запись остановлена")
+			require.Len(t, env.sender.sent(), 1, "отправитель узнал о неудаче")
+		})
+	}
+}
+
+// Критерий приёмки 8. Повтор шага не создаёт второго приложения: пара «запись и
+// вид» уникальна, и вопрос «какой текст отдавать человеку» не становится
+// вопросом порядка записи.
+func TestRepeatedStoreKeepsSingleText(t *testing.T) {
+	env := newPipelineEnv(t, &okMetaViewer{}, &okConverter{})
+
+	record := newTelegramRecord(t, env)
+
+	first, err := env.repos.Texts.Put(record.Id, entity.TextKindTranscript, "первый разбор")
+	require.NoError(t, err)
+	second, err := env.repos.Texts.Put(record.Id, entity.TextKindTranscript, "второй разбор")
+	require.NoError(t, err)
+
+	assert.Equal(t, first.Id, second.Id, "строка та же, а не вторая")
+
+	stored, err := env.repos.Texts.GetByID(first.Id)
+	require.NoError(t, err)
+	assert.Equal(t, "второй разбор", stored.Contents)
+
+	count, err := env.app.CountRecords(migrations.TextsCollection)
+	require.NoError(t, err)
+	assert.Equal(t, int64(1), count, "второго комплекта строк не завелось")
+}
+
+// Пауза растёт с числом отказов и упирается в потолок.
 func TestRetryDelayGrowsAndCaps(t *testing.T) {
 	assert.Equal(t, retryDelayBase, retryDelay(1))
 	assert.Equal(t, 2*retryDelayBase, retryDelay(2))
@@ -241,6 +530,42 @@ func TestRetryDelayGrowsAndCaps(t *testing.T) {
 	assert.Equal(t, retryDelayBase, retryDelay(0), "нулевая попытка не даёт нулевой паузы")
 }
 
+// Отказ шага не оставляет запись захваченной до конца срока: захват снимается,
+// и запись ждёт нарастающую паузу. Иначе повтор наступал бы через часы.
+func TestFailedStepSchedulesRetryWithGrowingDelay(t *testing.T) {
+	env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
+
+	record := newTelegramRecord(t, env)
+
+	// Ссылка переставляется на запись о файле без содержимого: шаг отказывает на
+	// получении рабочей копии — то есть отказом, а не приговором записи.
+	files, err := env.app.FindCollectionByNameOrId(migrations.FilesCollection)
+	require.NoError(t, err)
+	empty := core.NewRecord(files)
+	empty.Set("location", entity.LocationLocal)
+	empty.Set("size", 1)
+	require.NoError(t, env.app.Save(empty))
+
+	stored, err := env.app.FindRecordById(migrations.RecordsCollection, record.Id)
+	require.NoError(t, err)
+	stored.Set("original_file", empty.Id)
+	require.NoError(t, env.app.Save(stored))
+
+	require.Error(t, env.service.RunStep(t.Context()))
+
+	after := readRecord(t, env, record.Id)
+	require.Nil(t, after.AcquisitionID, "захват снят: запись пригодна к повтору")
+	require.NotNil(t, after.DelayTime, "пауза поставлена")
+	firstDelay := time.Until(*after.DelayTime)
+
+	clearDelay(t, env, record.Id)
+	require.Error(t, env.service.RunStep(t.Context()))
+
+	after = readRecord(t, env, record.Id)
+	require.NotNil(t, after.DelayTime)
+	assert.Greater(t, time.Until(*after.DelayTime), firstDelay, "вторая пауза длиннее первой")
+}
+
 // Рабочая копия убирается на любом исходе, включая отказ. Забытая копия — это
 // шестичасовая запись во временном каталоге, и узнать о ней неоткуда.
 func TestWorkFileRemovedAfterIntakeFailure(t *testing.T) {
@@ -273,24 +598,43 @@ func TestWorkFileRemovedAfterSuccessfulIntake(t *testing.T) {
 	assert.Empty(t, leftovers, "рабочей копии после успеха не остаётся")
 }
 
-// Задача не остаётся ссылающейся на файл, которого нет: ссылка переставляется
-// только после того, как запись о новом файле существует.
-func TestJobNeverPointsToMissingFile(t *testing.T) {
+// Уборка проверяется и на шаге приведения: репозиторий даёт единственный способ
+// убрать копию, но зовёт его шаг. Копий здесь две — исходник и результат.
+func TestWorkFilesRemovedAfterConversionFailure(t *testing.T) {
+	tempDir := t.TempDir()
+	t.Setenv("TMPDIR", tempDir)
+
 	env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
 
-	job := newTelegramJob(t, env)
+	newTelegramRecord(t, env)
 
-	// Конвертация отказывает — задача уходит в `failed`, но ссылка остаётся на
-	// исходную запись, а не на несозданный результат.
-	require.NoError(t, env.service.FindAndRunConversionJob(t.Context()))
-
-	after, err := readJob(env.app, job.Id)
+	leftovers, err := filepath.Glob(filepath.Join(tempDir, "transcriber-*"))
 	require.NoError(t, err)
-	assert.Equal(t, entity.StateFailed, after.State)
-	require.NotNil(t, after.FileID)
+	require.Empty(t, leftovers, "приём убрал свою рабочую копию")
 
-	file, err := env.fileRepo.GetByID(*after.FileID)
-	require.NoError(t, err, "ссылка задачи ведёт на существующую запись о файле")
+	require.NoError(t, env.service.RunStep(t.Context()))
+
+	leftovers, err = filepath.Glob(filepath.Join(tempDir, "transcriber-*"))
+	require.NoError(t, err)
+	assert.Empty(t, leftovers, "ни исходной копии, ни копии под результат не осталось")
+}
+
+// Запись не остаётся ссылающейся на файл, которого нет: ссылка ставится только
+// после того, как запись о файле существует.
+func TestRecordNeverPointsToMissingFile(t *testing.T) {
+	env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
+
+	record := newTelegramRecord(t, env)
+
+	require.NoError(t, env.service.RunStep(t.Context()))
+
+	after := readRecord(t, env, record.Id)
+	assert.True(t, after.IsHalted(), "приговор шага остановил запись")
+	require.NotNil(t, after.OriginalFileID)
+	assert.Nil(t, after.NormalizedFileID, "ссылки на несозданный результат не появилось")
+
+	file, err := env.fileRepo.GetByID(*after.OriginalFileID)
+	require.NoError(t, err, "ссылка ведёт на существующую запись о файле")
 	assert.NotEmpty(t, file.FileName)
 }
 
@@ -300,11 +644,11 @@ func TestStoredContentSurvivesRoundTrip(t *testing.T) {
 
 	content := strings.Repeat("запись ", 1000)
 
-	job, err := env.service.CreateJobFromApi(t.Context(), strings.NewReader(content), "sample.mp3", newOwner(t, env.app))
+	record, err := env.service.CreateJobFromApi(t.Context(), strings.NewReader(content), "sample.mp3", newOwner(t, env.app))
 	require.NoError(t, err)
-	require.NotNil(t, job.FileID)
+	require.NotNil(t, record.OriginalFileID)
 
-	reader, err := env.fileRepo.Open(*job.FileID)
+	reader, err := env.fileRepo.Open(*record.OriginalFileID)
 	require.NoError(t, err)
 	defer reader.Close()
 
@@ -312,22 +656,22 @@ func TestStoredContentSurvivesRoundTrip(t *testing.T) {
 	require.NoError(t, err)
 	assert.Equal(t, content, string(stored))
 
-	// И длина в учёте совпадает с длиной принятого.
-	file, err := env.fileRepo.GetByID(*job.FileID)
+	file, err := env.fileRepo.GetByID(*record.OriginalFileID)
 	require.NoError(t, err)
 	assert.Equal(t, int64(len(content)), file.Size)
+	assert.Equal(t, "mp3", file.Format, "формат копии записан")
 }
 
-// Рабочая копия хранимого файла отдаётся именем на диске — так её получают
-// шаги, отдающие файл внешней программе.
+// Рабочая копия хранимого файла отдаётся именем на диске — так её получают шаги,
+// отдающие файл внешней программе.
 func TestLocalizeGivesReadableCopy(t *testing.T) {
 	env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
 
-	job, err := env.service.CreateJobFromApi(t.Context(), strings.NewReader("содержимое"), "sample.mp3", newOwner(t, env.app))
+	record, err := env.service.CreateJobFromApi(t.Context(), strings.NewReader("содержимое"), "sample.mp3", newOwner(t, env.app))
 	require.NoError(t, err)
-	require.NotNil(t, job.FileID)
+	require.NotNil(t, record.OriginalFileID)
 
-	work, err := env.fileRepo.Localize(*job.FileID)
+	work, err := env.fileRepo.Localize(*record.OriginalFileID)
 	require.NoError(t, err)
 
 	content, err := os.ReadFile(work.Path())
@@ -339,86 +683,10 @@ func TestLocalizeGivesReadableCopy(t *testing.T) {
 	assert.True(t, os.IsNotExist(err), "закрытая копия убрана")
 }
 
-// Уборка рабочей копии проверяется и на шаге конвертации: репозиторий даёт
-// единственный способ убрать копию, но зовёт его шаг, и норма держится
-// проверкой, а не построением. Копий здесь две — исходник и результат.
-func TestWorkFilesRemovedAfterConversionFailure(t *testing.T) {
-	tempDir := t.TempDir()
-	t.Setenv("TMPDIR", tempDir)
-
-	env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
-
-	newTelegramJob(t, env)
-
-	// Приём уже отработал — убеждаемся, что за собой он прибрал, иначе остаток
-	// от него зачёлся бы шагу конвертации.
-	leftovers, err := filepath.Glob(filepath.Join(tempDir, "transcriber-*"))
-	require.NoError(t, err)
-	require.Empty(t, leftovers, "приём убрал свою рабочую копию")
-
-	// Конвертация отказывает — задача уходит в `failed`, копии убраны.
-	require.NoError(t, env.service.FindAndRunConversionJob(t.Context()))
-
-	leftovers, err = filepath.Glob(filepath.Join(tempDir, "transcriber-*"))
-	require.NoError(t, err)
-	assert.Empty(t, leftovers, "ни исходной копии, ни копии под результат не осталось")
-}
-
-// readJob читает задачу мимо сужения владельцем.
-//
-// Читающий метод хранилища отдаёт задачу только её владельцу, а проверки
-// конвейера смотрят задачи, принятые ботом: владельца у таких нет вовсе, и по
-// правилу разграничения они не достаются никому. Проверке нужен не доступ, а
-// состояние записи после шага, поэтому она берёт его прямо из хранилища. Это
-// не второй способ читать задачу в сервисе — в сервисе способ по-прежнему один.
-func readJob(app core.App, id string) (*entity.TranscribeJob, error) {
-	record, err := app.FindRecordById(migrations.JobsCollection, id)
-	if err != nil {
-		return nil, err
-	}
-
-	job := &entity.TranscribeJob{
-		Id:        record.Id,
-		State:     record.GetString("state"),
-		Source:    record.GetString("source"),
-		Attempts:  record.GetInt("attempts"),
-		CreatedAt: record.GetDateTime("created").Time(),
-		UpdatedAt: record.GetDateTime("updated").Time(),
-	}
-
-	for _, field := range []struct {
-		name string
-		dst  **string
-	}{
-		{"owner", &job.OwnerID},
-		{"file", &job.FileID},
-		{"error_text", &job.ErrorText},
-		{"acquisition_id", &job.AcquisitionID},
-		{"recognition_op_id", &job.RecognitionOpID},
-		{"transcription_text", &job.TranscriptionText},
-	} {
-		if value := record.GetString(field.name); value != "" {
-			stored := value
-			*field.dst = &stored
-		}
-	}
-
-	if delay := record.GetDateTime("delay_time"); !delay.IsZero() {
-		moment := delay.Time()
-		job.DelayTime = &moment
-	}
-	if acquired := record.GetDateTime("acquire_time"); !acquired.IsZero() {
-		moment := acquired.Time()
-		job.AcquireTime = &moment
-	}
-
-	return job, nil
-}
-
 // newOwner заводит учётную запись и отдаёт её идентификатор.
 //
 // Владелец — связь с коллекцией пользователей, и хранилище проверяет, что такая
-// запись есть: выдуманный идентификатор задачу завести не даст.
+// запись есть: выдуманный идентификатор запись завести не даст.
 func newOwner(t *testing.T, app core.App) string {
 	t.Helper()
 
@@ -428,8 +696,77 @@ func newOwner(t *testing.T, app core.App) string {
 	record := core.NewRecord(users)
 	record.Set("email", uuid.NewString()+"@example.test")
 	record.Set("verified", true)
-	record.SetPassword(uuid.NewString())
+	record.Set("password", uuid.NewString())
 	require.NoError(t, app.Save(record))
 
 	return record.Id
 }
+
+// Остановка приговором шага засчитывается **отказом**, а не успехом, и пишет в
+// журнал записи одну строку, а не две.
+//
+// Пока исход шага выводился из «шаг не вернул ошибку», остановленная запись
+// получала событием `done` вслед за `halted` и растила счётчик успехов — то есть
+// единственный канал владельца молчал ровно там, где запись встала.
+func TestHaltIsCountedAsFailureAndLoggedOnce(t *testing.T) {
+	env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
+
+	beforeOk := stageCount(t, entity.StateUploaded, "false")
+	beforeErr := stageCount(t, entity.StateUploaded, "true")
+
+	record := newTelegramRecord(t, env)
+	require.NoError(t, env.service.RunStep(t.Context()))
+
+	after := readRecord(t, env, record.Id)
+	require.True(t, after.IsHalted(), "приговор шага остановил запись")
+
+	assert.InDelta(t, beforeErr+1, stageCount(t, entity.StateUploaded, "true"), 0,
+		"остановка засчитана отказом")
+	assert.InDelta(t, beforeOk, stageCount(t, entity.StateUploaded, "false"), 0,
+		"и успехом не засчитана")
+
+	events := recordEvents(t, env, record.Id)
+	require.Len(t, events, 1, "одна строка журнала, а не две")
+	assert.Equal(t, entity.EventOutcomeFailed, events[0].GetString("outcome"),
+		"исход назван приговором, а не сделанной работой")
+}
+
+// Откладывание опроса в журнал событий не пишется: часовое ожидание чужой
+// операции дало бы там сотни строк ни о чём, и журнал, заведённый для человека,
+// стал бы нечитаемым ровно у долгой записи.
+func TestPostponeWritesNoEvent(t *testing.T) {
+	rec := &countingRecognizer{}
+	rec.inProgress.Store(5)
+	env := newPipelineEnvWith(t, &okMetaViewer{}, &okConverter{}, rec)
+
+	record := newTelegramRecord(t, env)
+	require.NoError(t, env.service.RunStep(t.Context())) // приведение
+	require.NoError(t, env.service.RunStep(t.Context())) // отправка
+	require.Equal(t, entity.StateSubmitted, readRecord(t, env, record.Id).State)
+
+	before := len(recordEvents(t, env, record.Id))
+
+	for range 5 {
+		clearDelay(t, env, record.Id)
+		require.NoError(t, env.service.RunStep(t.Context()))
+	}
+
+	assert.Len(t, recordEvents(t, env, record.Id), before,
+		"пять откладываний не оставили в журнале ни строки")
+}
+
+// recordEvents читает журнал событий одной записи в порядке заведения.
+func recordEvents(t *testing.T, env *pipelineEnv, recordID string) []*core.Record {
+	t.Helper()
+
+	all, err := env.app.FindAllRecords(migrations.RecordEventsCollection)
+	require.NoError(t, err)
+
+	var own []*core.Record
+	for _, event := range all {
+		if event.GetString("record") == recordID {
+			own = append(own, event)
+		}
+	}
+	return own
+}

internal/service/recognition_test.go

@@ -2,267 +2,196 @@ package service
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"io"
-	"strings"
+	"sync/atomic"
 	"testing"
-	"time"
 
+	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	"git.vakhrushev.me/av/transcriber/internal/adapter/repo/pocketbase/migrations"
-	"git.vakhrushev.me/av/transcriber/internal/contract"
 	"git.vakhrushev.me/av/transcriber/internal/entity"
 )
 
-// Шаги распознавания переписаны переездом на новое хранилище целиком: они берут
-// содержимое по записи, заводят запись о копии во внешнем хранилище и пишут
-// результат условием по держателю захвата. Подставной распознаватель проекта
-// умеет только «завершено с фиксированным текстом», поэтому ветки ожидания,
-// отказа операции и пустого текста изобразить нечем — для них нужен управляемый
-// двойник.
-
-// scriptedRecognizer отдаёт заданный исход проверки операции и заданный текст.
-type scriptedRecognizer struct {
-	result       *entity.RecognitionResult
-	text         string
-	recognizeErr error
-
-	recognizeCalls int
-	lastObjectKey  string
+// countingRecognizer считает обращения наружу: за них платят по факту, и повтор
+// оплаченного шага — самый дорогой класс дефекта в этом сервисе.
+type countingRecognizer struct {
+	uploads    atomic.Int64
+	submits    atomic.Int64
+	fetches    atomic.Int64
+	parses     atomic.Int64
+	objectHere atomic.Bool
+	inProgress atomic.Int64
 }
 
-func (r *scriptedRecognizer) Recognize(_ context.Context, file io.Reader, fileName string) (string, error) {
-	r.recognizeCalls++
-	r.lastObjectKey = fileName
-	if r.recognizeErr != nil {
-		return "", r.recognizeErr
+func (r *countingRecognizer) Provider() string { return "counting" }
+
+func (r *countingRecognizer) Model() string { return "counting" }
+
+func (r *countingRecognizer) Upload(_ context.Context, _ io.Reader, objectKey string) (string, error) {
+	r.uploads.Add(1)
+	r.objectHere.Store(true)
+	return "counting://" + objectKey, nil
+}
+
+func (r *countingRecognizer) ObjectExists(context.Context, string, int64) (bool, error) {
+	return r.objectHere.Load(), nil
+}
+
+func (r *countingRecognizer) SourceURI(objectKey string) string {
+	return "counting://" + objectKey
+}
+
+func (r *countingRecognizer) Submit(context.Context, string) (string, error) {
+	r.submits.Add(1)
+	return uuid.NewString(), nil
+}
+
+func (r *countingRecognizer) CheckStatus(context.Context, string) (*entity.RecognitionResult, error) {
+	if r.inProgress.Load() > 0 {
+		r.inProgress.Add(-1)
+		return entity.NewInProgressResult(), nil
 	}
-	// Содержимое обязано быть читаемым: шаг отдаёт его наружу потоком.
-	if _, err := io.Copy(io.Discard, file); err != nil {
-		return "", err
+	return entity.NewCompletedResult(), nil
+}
+
+func (r *countingRecognizer) Fetch(context.Context, string) (*entity.RecognitionOutcome, error) {
+	r.fetches.Add(1)
+	return r.Parse(countingPayload(t0Replicas))
+}
+
+func (r *countingRecognizer) Parse(raw []byte) (*entity.RecognitionOutcome, error) {
+	r.parses.Add(1)
+
+	var replicas []entity.Replica
+	if err := json.Unmarshal(raw, &replicas); err != nil {
+		return nil, errors.New("не разобрать сохранённый ответ")
 	}
-	return "operation-id", nil
+
+	var plain []byte
+	for _, replica := range replicas {
+		if len(plain) > 0 {
+			plain = append(plain, ' ')
+		}
+		plain = append(plain, replica.Text...)
+	}
+
+	return &entity.RecognitionOutcome{Replicas: replicas, PlainText: string(plain), Raw: raw}, nil
 }
 
-func (r *scriptedRecognizer) GetRecognitionText(context.Context, string) (string, error) {
-	return r.text, nil
+var t0Replicas = []entity.Replica{
+	{StartMs: 0, EndMs: 900, Text: "Первая реплика."},
+	{StartMs: 900, EndMs: 1800, Text: "Вторая реплика."},
 }
 
-func (r *scriptedRecognizer) CheckRecognitionStatus(context.Context, string) (*entity.RecognitionResult, error) {
-	return r.result, nil
+func countingPayload(replicas []entity.Replica) []byte {
+	raw, err := json.Marshal(replicas)
+	if err != nil {
+		panic(err)
+	}
+	return raw
 }
 
-// convertedJob доводит задачу до состояния, с которого работает шаг
-// распознавания: запись принята и сконвертирована.
-func convertedJob(t *testing.T, env *pipelineEnv) *entity.TranscribeJob {
-	t.Helper()
+// Критерий приёмки 4. Структура реплик строится из сохранённого ответа
+// провайдера без единого обращения к нему: результат операции не
+// переспрашивается, и архив пересчитывается из сохранённого без рубля.
+func TestStructureIsBuiltFromStoredPayload(t *testing.T) {
+	rec := &countingRecognizer{}
+	env := newPipelineEnvWith(t, &okMetaViewer{}, &okConverter{}, rec)
 
-	job := newTelegramJob(t, env)
+	record := newTelegramRecord(t, env)
+	drain(t, env, record.Id)
 
-	acquired, err := env.jobRepo.FindAndAcquire(entity.StateCreated, "setup", time.Now().Add(-time.Hour))
+	after := readRecord(t, env, record.Id)
+	require.Equal(t, entity.StateDone, after.State)
+	require.NotNil(t, after.RecognitionID)
+
+	// Сохранённый ответ на месте и читается целиком.
+	raw, err := env.repos.Recognitions.ReadRaw(*after.RecognitionID)
 	require.NoError(t, err)
-	acquired.MoveToState(entity.StateConverted)
-	require.NoError(t, env.jobRepo.Save(acquired, "setup"))
+	require.NotEmpty(t, raw, "сырой ответ провайдера сохранён")
 
-	return job
-}
+	// А теперь — построение структуры из сохранённого, без обращений наружу.
+	fetchesBefore := rec.fetches.Load()
+	submitsBefore := rec.submits.Load()
 
-// withRecognizer пересобирает сервис с управляемым распознавателем поверх того
-// же хранилища.
-func withRecognizer(env *pipelineEnv, rec contract.AudioRecognizer) *TranscribeService {
-	return NewTranscribeService(
-		env.jobRepo,
-		env.fileRepo,
-		&okMetaViewer{},
-		&failingConverter{},
-		rec,
-		env.sender,
-		env.service.logger,
-	)
-}
-
-// Шаг распознавания отдаёт содержимое наружу, заводит запись о копии во внешнем
-// хранилище и переставляет на неё ссылку задачи — только после того, как запись
-// о копии существует.
-func TestTranscribeJobHandsRecordOverAndMovesOn(t *testing.T) {
-	env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
-	job := convertedJob(t, env)
-
-	rec := &scriptedRecognizer{result: entity.NewInProgressResult()}
-	svc := withRecognizer(env, rec)
-
-	require.NoError(t, svc.FindAndRunTranscribeJob(t.Context()))
-
-	assert.Equal(t, 1, rec.recognizeCalls, "содержимое отдано распознавателю")
-	assert.NotEmpty(t, rec.lastObjectKey, "ключ объекта назван")
-
-	after, err := readJob(env.app, job.Id)
+	outcome, err := env.service.recognizer.Parse(raw)
 	require.NoError(t, err)
-	assert.Equal(t, entity.StateTranscribe, after.State)
-	require.NotNil(t, after.RecognitionOpID)
-	assert.Equal(t, "operation-id", *after.RecognitionOpID)
-	require.NotNil(t, after.DelayTime, "задержка перед первой проверкой поставлена")
+	require.Len(t, outcome.Replicas, len(t0Replicas), "структура собрана")
+	assert.Equal(t, t0Replicas[0].Text, outcome.Replicas[0].Text)
+	assert.Equal(t, t0Replicas[0].StartMs, outcome.Replicas[0].StartMs, "время реплики сохранено")
 
-	// Ссылка задачи ведёт на существующую запись о копии, а не на несозданную.
-	require.NotNil(t, after.FileID)
-	copyRecord, err := env.fileRepo.GetByID(*after.FileID)
+	assert.Equal(t, fetchesBefore, rec.fetches.Load(), "к провайдеру за результатом не ходили")
+	assert.Equal(t, submitsBefore, rec.submits.Load(), "и новой операции не заводили")
+
+	// Структура записи собрана из того же ответа и лежит своей строкой.
+	require.NotNil(t, after.StructureID)
+	structure, err := env.repos.Structures.GetByID(*after.StructureID)
 	require.NoError(t, err)
-	assert.Equal(t, entity.LocationS3, copyRecord.Location)
+	assert.Equal(t, entity.StructureVersion, structure.Version)
+	require.Len(t, structure.Replicas, len(t0Replicas))
+	assert.Equal(t, t0Replicas[1].Text, structure.Replicas[1].Text)
 }
 
-// Отказ распознавателя не двигает задачу: она остаётся пригодной к повтору.
-func TestTranscribeJobKeepsJobRetryableOnRecognizerFailure(t *testing.T) {
-	env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
-	job := convertedJob(t, env)
+// Шаг с внешней оплатой проверяет сделанное: объект нужного размера на месте —
+// заливку не повторяем; операция заведена — не платим второй раз.
+func TestPaidWorkIsNotRepeated(t *testing.T) {
+	rec := &countingRecognizer{}
+	env := newPipelineEnvWith(t, &okMetaViewer{}, &okConverter{}, rec)
 
-	rec := &scriptedRecognizer{recognizeErr: errors.New("распознаватель недоступен")}
-	svc := withRecognizer(env, rec)
+	record := newTelegramRecord(t, env)
 
-	require.Error(t, svc.FindAndRunTranscribeJob(t.Context()))
+	// Приведение.
+	require.NoError(t, env.service.RunStep(t.Context()))
+	require.Equal(t, entity.StateNormalized, readRecord(t, env, record.Id).State)
 
-	after, err := readJob(env.app, job.Id)
-	require.NoError(t, err)
-	assert.Equal(t, entity.StateConverted, after.State, "задача осталась на своём шаге")
-	assert.Nil(t, after.AcquisitionID, "захват снят: задача пригодна к повтору")
-	assert.NotNil(t, after.DelayTime, "пауза перед повтором поставлена")
-	assert.Empty(t, env.sender.messages, "отправителю про повторимый отказ не пишут")
+	// Отправка.
+	require.NoError(t, env.service.RunStep(t.Context()))
+	require.Equal(t, int64(1), rec.uploads.Load(), "залили один раз")
+	require.Equal(t, int64(1), rec.submits.Load(), "и заплатили один раз")
+
+	// Возвращаем запись на рубеж отправки — так это выглядит, когда шаг оборвался
+	// после оплаты, а захват протух.
+	after := readRecord(t, env, record.Id)
+	after.MoveToState(entity.StateNormalized)
+	require.NoError(t, env.recordRepo.Save(after, ""))
+
+	require.NoError(t, env.service.RunStep(t.Context()))
+
+	assert.Equal(t, int64(1), rec.uploads.Load(), "объект на месте — заливка не повторилась")
+	assert.Equal(t, int64(1), rec.submits.Load(), "операция заведена — второй раз не платим")
 }
 
-// transcribingJob доводит задачу до состояния ожидания операции.
-func transcribingJob(t *testing.T, env *pipelineEnv, rec contract.AudioRecognizer) *entity.TranscribeJob {
-	t.Helper()
+// Ожидание чужой операции откладывается своей задержкой, отказов не тратит и
+// рубежа не двигает.
+func TestPollingPostponesWithoutSpendingAttempts(t *testing.T) {
+	rec := &countingRecognizer{}
+	rec.inProgress.Store(3)
+	env := newPipelineEnvWith(t, &okMetaViewer{}, &okConverter{}, rec)
 
-	job := convertedJob(t, env)
-	require.NoError(t, withRecognizer(env, rec).FindAndRunTranscribeJob(t.Context()))
+	record := newTelegramRecord(t, env)
 
-	clearDelay(t, env, job.Id)
-	return job
-}
+	require.NoError(t, env.service.RunStep(t.Context())) // приведение
+	require.NoError(t, env.service.RunStep(t.Context())) // отправка
+	require.Equal(t, entity.StateSubmitted, readRecord(t, env, record.Id).State)
 
-// Ожидание чужой операции попытку не тратит и опрос не учащает: шаг отработал
-// без отказа, и задержка у него своя, числом.
-func TestCheckJobWaitsWithoutSpendingAttempts(t *testing.T) {
-	env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
-	rec := &scriptedRecognizer{result: entity.NewInProgressResult()}
-	job := transcribingJob(t, env, rec)
+	entered := readRecord(t, env, record.Id).StateEnteredAt
 
-	svc := withRecognizer(env, rec)
+	var delays []int64
+	for range 3 {
+		clearDelay(t, env, record.Id)
+		require.NoError(t, env.service.RunStep(t.Context()))
 
-	for i := 0; i < 3; i++ {
-		require.NoError(t, svc.FindAndRunTranscribeCheckJob(t.Context()))
+		after := readRecord(t, env, record.Id)
+		require.Equal(t, entity.StateSubmitted, after.State, "рубеж не сдвинут откладыванием")
+		assert.Equal(t, 0, after.Attempts, "ожидание чужой операции отказа не тратит")
+		assert.WithinDuration(t, entered, after.StateEnteredAt, 0, "и отсчёт застревания не двигает")
 
-		after, err := readJob(env.app, job.Id)
-		require.NoError(t, err)
-		assert.Equal(t, entity.StateTranscribe, after.State)
-		assert.Equal(t, 0, after.Attempts, "ожидание операции попытку не тратит")
 		require.NotNil(t, after.DelayTime)
-		assert.InDelta(t, nextCheckDelay.Seconds(), time.Until(*after.DelayTime).Seconds(), 2,
-			"задержка опроса не выродилась в наименьшую паузу повтора")
-
-		clearDelay(t, env, job.Id)
+		delays = append(delays, after.DelayTime.Unix())
 	}
-}
 
-// Отказ операции распознавания — приговор записи: задача уходит в `failed`, а
-// отправитель узнаёт причину человеческим текстом.
-func TestCheckJobFailsJobAndTellsSender(t *testing.T) {
-	env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
-	rec := &scriptedRecognizer{result: entity.NewInProgressResult()}
-	job := transcribingJob(t, env, rec)
-
-	rec.result = entity.NewFailedResult("операция отклонена")
-	svc := withRecognizer(env, rec)
-
-	require.NoError(t, svc.FindAndRunTranscribeCheckJob(t.Context()))
-
-	after, err := readJob(env.app, job.Id)
-	require.NoError(t, err)
-	assert.Equal(t, entity.StateFailed, after.State)
-
-	require.Len(t, env.sender.messages, 1, "отправитель узнал об отказе")
-	assert.Contains(t, env.sender.messages[0], "сбой при распознавании файла")
-	assert.NotContains(t, env.sender.messages[0], "операция отклонена",
-		"машинная причина отправителю не идёт")
-}
-
-// Готовая операция завершает задачу и отдаёт текст отправителю ровно один раз.
-func TestCheckJobCompletesAndAnswersOnce(t *testing.T) {
-	env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
-	rec := &scriptedRecognizer{result: entity.NewInProgressResult()}
-	job := transcribingJob(t, env, rec)
-
-	rec.result = entity.NewCompletedResult()
-	rec.text = "расшифровка записи"
-	svc := withRecognizer(env, rec)
-
-	require.NoError(t, svc.FindAndRunTranscribeCheckJob(t.Context()))
-
-	after, err := readJob(env.app, job.Id)
-	require.NoError(t, err)
-	assert.Equal(t, entity.StateDone, after.State)
-	require.NotNil(t, after.TranscriptionText)
-	assert.Equal(t, "расшифровка записи", *after.TranscriptionText)
-
-	require.Len(t, env.sender.messages, 1, "отправитель получил ровно один ответ")
-	assert.Equal(t, "расшифровка записи", env.sender.messages[0])
-
-	// И задача из выборки исчезла: второй ответ отправителю неоткуда взяться.
-	_, err = env.jobRepo.FindAndAcquire(entity.StateTranscribe, "next", time.Now().Add(-time.Hour))
-	var missing *contract.JobNotFoundError
-	assert.ErrorAs(t, err, &missing)
-}
-
-// Пустая расшифровка — не отказ: задача завершается, а отправителю уходит
-// объяснение вместо пустого сообщения.
-func TestCheckJobCompletesEmptyTextWithExplanation(t *testing.T) {
-	env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
-	rec := &scriptedRecognizer{result: entity.NewInProgressResult()}
-	job := transcribingJob(t, env, rec)
-
-	rec.result = entity.NewCompletedResult()
-	rec.text = ""
-	svc := withRecognizer(env, rec)
-
-	require.NoError(t, svc.FindAndRunTranscribeCheckJob(t.Context()))
-
-	after, err := readJob(env.app, job.Id)
-	require.NoError(t, err)
-	assert.Equal(t, entity.StateDone, after.State)
-
-	require.Len(t, env.sender.messages, 1)
-	assert.Contains(t, strings.ToLower(env.sender.messages[0]), "нет текста")
-}
-
-// Шаг, потерявший захват за время работы, результата не пишет и отправителю не
-// отвечает: иначе два воркера пишут в одну задачу, а отправитель получает два
-// ответа на одну запись.
-func TestCheckJobWritesNothingWhenAcquisitionLost(t *testing.T) {
-	env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
-	rec := &scriptedRecognizer{result: entity.NewInProgressResult()}
-	job := transcribingJob(t, env, rec)
-
-	rec.result = entity.NewCompletedResult()
-	rec.text = "расшифровка записи"
-
-	// Захват задачи достался другому, пока шаг работал.
-	acquired, err := env.jobRepo.FindAndAcquire(entity.StateTranscribe, "mine", time.Now().Add(-time.Hour))
-	require.NoError(t, err)
-
-	record, err := env.app.FindRecordById(migrations.JobsCollection, job.Id)
-	require.NoError(t, err)
-	record.Set("acquisition_id", "someone-else")
-	require.NoError(t, env.app.Save(record))
-
-	svc := withRecognizer(env, rec)
-	err = svc.checkTranscribeJob(t.Context(), acquired, "mine")
-
-	var lost *contract.LostAcquisitionError
-	require.ErrorAs(t, err, &lost)
-
-	after, err := readJob(env.app, job.Id)
-	require.NoError(t, err)
-	assert.Equal(t, entity.StateTranscribe, after.State, "результат не записан")
-	assert.Empty(t, env.sender.messages, "отправителю ничего не отправлено")
+	assert.Len(t, delays, 3, "все три прогона отложили работу")
 }

internal/service/shutdown_test.go

@@ -8,7 +8,6 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	"git.vakhrushev.me/av/transcriber/internal/adapter/repo/pocketbase/migrations"
 	"git.vakhrushev.me/av/transcriber/internal/contract"
 	"git.vakhrushev.me/av/transcriber/internal/entity"
 )
@@ -28,43 +27,43 @@ func (c *killedConverter) Convert(ctx context.Context, _, _ string) error {
 	return errors.New("ffmpeg conversion failed: signal: killed")
 }
 
-// Остановка сервиса посреди конвертации не выносит записи приговора: задача
-// остаётся пригодной к повтору, попытку не тратит и отправителю о сбое,
-// которого не было, не сообщает. Прежде любой отказ `Convert` уводил задачу в
-// терминальное `failed`, откуда её возвращает только владелец правкой в панели.
-func TestShutdownDuringConversionKeepsJobRetryable(t *testing.T) {
+// Критерий приёмки 9. Остановка сервиса посреди приведения не выносит записи
+// приговора и **не тратит отказа**: запись не виновата в том, что нас
+// перезапустили, и несколько выкладок подряд иначе останавливают здоровую
+// многочасовую запись с приговором «попытки исчерпаны».
+func TestShutdownDuringConversionKeepsRecordRetryable(t *testing.T) {
 	ctx, cancel := context.WithCancel(t.Context())
 	defer cancel()
 
 	converter := &killedConverter{cancel: cancel}
 	env := newPipelineEnv(t, &okMetaViewer{}, converter)
-	job := newTelegramJob(t, env)
+	record := newTelegramRecord(t, env)
 
-	err := env.service.FindAndRunConversionJob(ctx)
+	err := env.service.RunStep(ctx)
 
 	require.Error(t, err, "шаг обязан сообщить об обрыве наверх")
 	require.ErrorIs(t, err, context.Canceled, "обрыв узнаётся по смыслу, а не по тексту")
 
-	after, err := readJob(env.app, job.Id)
-	require.NoError(t, err)
+	after := readRecord(t, env, record.Id)
 
-	assert.Equal(t, entity.StateCreated, after.State, "задача осталась на повтор, а не похоронена")
-	assert.Nil(t, after.AcquisitionID, "захват снят: задачу возьмёт следующий прогон")
-	assert.Equal(t, 0, after.Attempts, "остановка попытки не тратит")
-	assert.Nil(t, after.ErrorText, "приговора не выносили")
-	assert.Empty(t, env.sender.messages, "отправителю о несуществующем сбое не сообщают")
+	assert.Equal(t, entity.StateUploaded, after.State, "запись осталась на повтор")
+	assert.False(t, after.IsHalted(), "приговора не выносили")
+	assert.Nil(t, after.AcquisitionID, "захват снят: запись возьмёт следующий прогон")
+	assert.Equal(t, 0, after.Attempts, "остановка отказа не тратит")
+	assert.Nil(t, after.ErrorText)
+	assert.Empty(t, env.sender.sent(), "отправителю о несуществующем сбое не сообщают")
 }
 
-// Задача, которую шаг не успел взять, потому что нас уже остановили, остаётся
-// нетронутой: захват не случился, попытка не потрачена.
-func TestShutdownBeforeStepLeavesJobUntouched(t *testing.T) {
+// Запись, которую шаг не успел взять, потому что нас уже остановили, остаётся
+// нетронутой: захват не случился, отказ не потрачен.
+func TestShutdownBeforeStepLeavesRecordUntouched(t *testing.T) {
 	env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
-	job := newTelegramJob(t, env)
+	record := newTelegramRecord(t, env)
 
 	ctx, cancel := context.WithCancel(t.Context())
 	cancel()
 
-	err := env.service.FindAndRunConversionJob(ctx)
+	err := env.service.RunStep(ctx)
 
 	// Исход «шаг не сделал ничего» — это `NoopJobError`: воркер не пишет о нём
 	// владельцу и не считает его в метрику.
@@ -72,12 +71,8 @@ func TestShutdownBeforeStepLeavesJobUntouched(t *testing.T) {
 	var noop *contract.NoopJobError
 	require.ErrorAs(t, err, &noop)
 
-	after, err := readJob(env.app, job.Id)
-	require.NoError(t, err)
-	assert.Equal(t, entity.StateCreated, after.State)
-	assert.Equal(t, 0, after.Attempts, "захвата не было — попытке взяться неоткуда")
-
-	record, err := env.app.FindRecordById(migrations.JobsCollection, job.Id)
-	require.NoError(t, err)
-	assert.Empty(t, record.GetString("acquisition_id"))
+	after := readRecord(t, env, record.Id)
+	assert.Equal(t, entity.StateUploaded, after.State)
+	assert.Equal(t, 0, after.Attempts, "захвата не было — отказу взяться неоткуда")
+	assert.Nil(t, after.AcquisitionID)
 }

internal/service/undelivered_test.go

@@ -14,10 +14,10 @@ import (
 	"git.vakhrushev.me/av/transcriber/internal/entity"
 )
 
-// Ответ отправителю уходит после того, как достигнутое состояние сохранено.
-// Значит, недоставка не может быть отказом шага: объявленный отказ засчитался
-// бы воркеру сбоем, лёг бы владельцу записью отказа и переписал бы служебные
-// поля завершённой задачи. Причин недоставки две, исход у них общий.
+// Ответ отправителю уходит после того, как достигнутый рубеж сохранён. Значит,
+// недоставка не может быть отказом шага: объявленный отказ засчитался бы воркеру
+// сбоем, лёг бы владельцу записью отказа и переписал бы служебные поля
+// доведённой записи. Причин недоставки две, исход у них общий.
 
 // downSender изображает неподнятый канал доставки: так ведёт себя заглушка,
 // которую ядро получает вместо отправителя Telegram.
@@ -31,91 +31,105 @@ func (s *downSender) Send(string, int64, *int) error {
 }
 
 // journalEnv пересобирает сервис с названным отправителем и своим журналом:
-// утверждения судят и состояние задачи, и то, что увидел владелец.
+// утверждения судят и состояние записи, и то, что увидел владелец.
 func journalEnv(
 	t *testing.T,
 	env *pipelineEnv,
-	rec contract.AudioRecognizer,
 	sender contract.TelegramMessageSender,
 ) (*TranscribeService, *bytes.Buffer) {
 	t.Helper()
 
 	journal := &bytes.Buffer{}
 	svc := NewTranscribeService(
-		env.jobRepo,
-		env.fileRepo,
+		env.repos,
 		&okMetaViewer{},
-		&failingConverter{},
-		rec,
+		&okConverter{},
+		env.service.recognizer,
 		sender,
+		testLimits,
 		slog.New(slog.NewTextHandler(journal, &slog.HandlerOptions{Level: slog.LevelDebug})),
 	)
 
 	return svc, journal
 }
 
-// Канал не поднят: задача доводится до конца, шаг отказа не объявляет, а
+// transcribedRecord доводит запись до рубежа, с которого уходит ответ.
+func transcribedRecord(t *testing.T, env *pipelineEnv, svc *TranscribeService) *entity.AudioRecord {
+	t.Helper()
+
+	record := newTelegramRecord(t, env)
+	for range 5 {
+		clearDelay(t, env, record.Id)
+		require.NoError(t, svc.RunStep(t.Context()))
+		if readRecord(t, env, record.Id).State == entity.StateTranscribed {
+			return readRecord(t, env, record.Id)
+		}
+	}
+	t.Fatal("запись не дошла до рубежа расшифровки")
+	return nil
+}
+
+// Канал не поднят: запись доводится до конца, шаг отказа не объявляет, а
 // владелец узнаёт о недоставке из журнала.
-func TestUndeliveredOnDownChannelKeepsJobDone(t *testing.T) {
-	env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
-	rec := &scriptedRecognizer{result: entity.NewInProgressResult()}
-	job := transcribingJob(t, env, rec)
+func TestUndeliveredOnDownChannelKeepsRecordDone(t *testing.T) {
+	env := newPipelineEnv(t, &okMetaViewer{}, &okConverter{})
 
-	rec.result = entity.NewCompletedResult()
-	rec.text = "расшифровка записи"
 	sender := &downSender{}
-	svc, journal := journalEnv(t, env, rec, sender)
+	svc, journal := journalEnv(t, env, sender)
+
+	record := transcribedRecord(t, env, svc)
 
 	// Шаг завершается без отказа — именно это воркер считает в свой счётчик.
-	require.NoError(t, svc.FindAndRunTranscribeCheckJob(t.Context()))
+	clearDelay(t, env, record.Id)
+	require.NoError(t, svc.RunStep(t.Context()))
 
 	assert.Equal(t, 1, sender.calls, "ответ до отправителя доехал")
 
-	after, err := readJob(env.app, job.Id)
+	after := readRecord(t, env, record.Id)
+	assert.Equal(t, entity.StateDone, after.State, "запись осталась на достигнутом рубеже")
+	assert.False(t, after.IsHalted(), "отказ записи не приписан")
+	require.NotNil(t, after.TranscriptTextID, "расшифровка сохранена")
+
+	text, err := env.repos.Texts.GetByID(*after.TranscriptTextID)
 	require.NoError(t, err)
-	assert.Equal(t, entity.StateDone, after.State, "задача осталась в достигнутом состоянии")
-	require.NotNil(t, after.TranscriptionText)
-	assert.Equal(t, "расшифровка записи", *after.TranscriptionText, "расшифровка сохранена")
-	assert.Nil(t, after.ErrorText, "отказ задаче не приписан")
+	require.NotEmpty(t, text.Contents)
 
 	written := journal.String()
 	assert.Contains(t, written, "Reply was not delivered", "недоставка названа")
-	assert.Contains(t, written, job.Id, "запись несёт идентификатор задачи")
+	assert.Contains(t, written, record.Id, "запись несёт идентификатор")
 	assert.Contains(t, written, "level=WARN", "объявленный режим — «может стать проблемой»")
-	assert.NotContains(t, written, "расшифровка записи", "текста расшифровки в журнале нет")
+	assert.NotContains(t, written, text.Contents, "текста расшифровки в журнале нет")
 }
 
-// Адресат у задачи не назван: исход тот же. Прежде эта ветка объявляла отказ
+// Адресат у записи не назван: исход тот же. Прежде эта ветка объявляла отказ
 // шага на уже завершённой работе.
-func TestUndeliveredWithoutChatKeepsJobDone(t *testing.T) {
-	env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
-	rec := &scriptedRecognizer{result: entity.NewInProgressResult()}
-	job := transcribingJob(t, env, rec)
+func TestUndeliveredWithoutChatKeepsRecordDone(t *testing.T) {
+	env := newPipelineEnv(t, &okMetaViewer{}, &okConverter{})
 
-	// Задача из Telegram, у которой чат не назван: такую отдаёт правка в панели.
-	// Колонка чистится мимо захвата — иначе setup унёс бы задачу у шага.
-	record, err := env.app.FindRecordById(migrations.JobsCollection, job.Id)
-	require.NoError(t, err)
-	record.Set("tg_chat_id", nil)
-	require.NoError(t, env.app.Save(record))
-
-	rec.result = entity.NewCompletedResult()
-	rec.text = "расшифровка записи"
 	sender := &downSender{}
-	svc, journal := journalEnv(t, env, rec, sender)
+	svc, journal := journalEnv(t, env, sender)
 
-	require.NoError(t, svc.FindAndRunTranscribeCheckJob(t.Context()))
+	record := transcribedRecord(t, env, svc)
+
+	// Запись из Telegram, у которой чат не назван: такую отдаёт правка в панели.
+	// Колонка чистится мимо захвата — иначе подготовка унесла бы запись у шага.
+	stored, err := env.app.FindRecordById(migrations.RecordsCollection, record.Id)
+	require.NoError(t, err)
+	stored.Set("tg_chat_id", nil)
+	require.NoError(t, env.app.Save(stored))
+
+	clearDelay(t, env, record.Id)
+	require.NoError(t, svc.RunStep(t.Context()))
 
 	assert.Equal(t, 0, sender.calls, "до отправителя дело не дошло: адресата нет")
 
-	after, err := readJob(env.app, job.Id)
-	require.NoError(t, err)
+	after := readRecord(t, env, record.Id)
 	assert.Equal(t, entity.StateDone, after.State)
-	assert.Nil(t, after.ErrorText, "отказ задаче не приписан")
+	assert.False(t, after.IsHalted(), "отказ записи не приписан")
 
 	written := journal.String()
 	assert.Contains(t, written, "Reply was not delivered")
-	assert.Contains(t, written, job.Id)
+	assert.Contains(t, written, record.Id)
 	assert.Contains(t, written, "chat is not specified", "причина названа")
 	assert.Contains(t, written, "level=ERROR",
 		"порча записи громче штатного «бот не настроен»: иначе сигнал утонет")
@@ -123,17 +137,17 @@ func TestUndeliveredWithoutChatKeepsJobDone(t *testing.T) {
 
 // Запись, принятая по HTTP, до отправителя не доходит вовсе: недоставки нет, и
 // записи о ней в журнале быть не должно — иначе журнал владельца заполнят
-// строки о задачах основного входа.
-func TestApiJobDoesNotReachSenderAndLogsNothing(t *testing.T) {
-	env := newPipelineEnv(t, &okMetaViewer{}, &failingConverter{})
+// строки о записях основного входа.
+func TestApiRecordDoesNotReachSenderAndLogsNothing(t *testing.T) {
+	env := newPipelineEnv(t, &okMetaViewer{}, &okConverter{})
 
-	job, err := env.service.CreateJobFromApi(t.Context(), strings.NewReader("запись"), "voice.ogg", newOwner(t, env.app))
+	record, err := env.service.CreateJobFromApi(t.Context(), strings.NewReader("запись"), "voice.ogg", newOwner(t, env.app))
 	require.NoError(t, err)
 
 	sender := &downSender{}
-	svc, journal := journalEnv(t, env, &scriptedRecognizer{}, sender)
+	svc, journal := journalEnv(t, env, sender)
 
-	require.NoError(t, svc.send(job, "расшифровка записи"))
+	require.NoError(t, svc.send(record, "расшифровка записи"))
 
 	assert.Equal(t, 0, sender.calls, "отправителя не звали")
 	assert.NotContains(t, journal.String(), "Reply was not delivered", "недоставки не было")