Method transitionTaskApproval

internal/task/manager.go:902–954

(
	ctx context.Context,
	id string,
	target ApprovalState,
	eventType string,
	actor ActorContext,
)

}

func (m *Service) transitionTaskApproval(
	ctx context.Context,
	id string,
	target ApprovalState,
	eventType string,
	actor ActorContext,
) (*Task, error) {
	if err := requireWriteAuthority(actor); err != nil {
		return nil, err
	}

	trimmedID := strings.TrimSpace(id)
	if trimmedID == "" {
		return nil, fmt.Errorf("%w: task id is required", ErrValidation)
	}

	record, err := m.store.GetTask(ctx, trimmedID)
	if err != nil {
		return nil, err
	}

	previousApprovalState := normalizeApprovalStateOrDefault(record.ApprovalPolicy, record.ApprovalState)
	if !taskApprovalDecisionAllowed(record, target) {
		return nil, fmt.Errorf(
			"%w: task %q cannot transition approval from %q to %q",
			ErrInvalidStatusTransition,
			record.ID,
			previousApprovalState,
			target.Normalize(),
		)
	}

	record.ApprovalState = target.Normalize()
	record.UpdatedAt = m.now().UTC()
	record.ClosedAt = time.Time{}
	if err := m.store.UpdateTask(ctx, record); err != nil {
		return nil, err
	}

	reconciled, err := m.reconcileTaskCascade(ctx, record.ID)
	if err != nil {
		return nil, err
	}
	if err := m.recordTaskEvent(ctx, reconciled.ID, "", eventType, actor, approvalDecisionTaskPayload{
		PreviousApprovalState: previousApprovalState,
		ApprovalState:         reconciled.ApprovalState,
		Status:                reconciled.Status,
	}); err != nil {
		return nil, err
	}

	return &reconciled, nil
}

func taskApprovalDecisionAllowed(record Task, target ApprovalState) bool {
	normalizedPolicy := normalizeApprovalPolicyOrDefault(record.ApprovalPolicy)