Method EnqueueRun

internal/task/manager.go:1792–1843

EnqueueRun persists one new queue-first task run under manager authority.

(ctx context.Context, spec EnqueueRun, actor ActorContext)

// EnqueueRun persists one new queue-first task run under manager authority.
func (m *Service) EnqueueRun(ctx context.Context, spec EnqueueRun, actor ActorContext) (*Run, error) {
	if err := requireWriteAuthority(actor); err != nil {
		return nil, err
	}

	normalizedSpec, err := normalizeEnqueueRunSpec(spec)
	if err != nil {
		return nil, err
	}
	if err := requireLifecycleIdempotency(actor, normalizedSpec.IdempotencyKey, "enqueue_run"); err != nil {
		return nil, err
	}
	if err := m.validateNetworkChannel("enqueue_run.network_channel", normalizedSpec.NetworkChannel); err != nil {
		return nil, err
	}

	_, run, existing, err := m.store.ReserveQueuedRun(
		ctx,
		normalizedSpec.TaskID,
		m.newID("run"),
		normalizedSpec.IdempotencyKey,
		actor.Origin,
		normalizedSpec.NetworkChannel,
		normalizedSpec.Metadata,
		m.now().UTC(),
		normalizedSpec.DesignationGroupID,
	)
	if err != nil {
		return nil, err
	}
	if existing {
		return &run, nil
	}

	reconciledTask, err := m.reconcileTaskCascade(ctx, normalizedSpec.TaskID)
	if err != nil {
		return nil, err
	}
	if err := m.recordTaskEvent(ctx, run.TaskID, run.ID, taskEventRunEnqueued, actor, runEnqueuedPayload{
		Attempt:               run.Attempt,
		Status:                run.Status,
		TaskStatus:            reconciledTask.Status,
		NetworkChannel:        run.NetworkChannel,
		CoordinationChannelID: run.CoordinationChannelID,
		IdempotencyKey:        run.IdempotencyKey,
	}); err != nil {
		return nil, err
	}
	m.dispatchTaskRunEnqueued(ctx, run, reconciledTask, actor, normalizedSpec.IdempotencyKey)

	return &run, nil
}

func validateTaskForEnqueue(taskRecord Task) error {
	switch taskRecord.Status.Normalize() {