After some adjustments, my abstract class now utilizes scaleX = -1 instead of flipped frames, resulting in a smoother operation. It's worth noting that there may be a slight increase in CPU usage, but testing will confirm this. In the worst-case scenario, I may need to include additional frames in the assets.

Cheers!

'use strict';

/**
 * AbstractCharacter
 * Provides common functionality for all characters
 * @author  Allandt Bik-Elliott
 * @version 0.1
 */

define(['easeljs'], function () {
    var AbstractCharacter = function (model) {
        this.model = model;

        // changed from original code
        // allows better encapsulation
        this._s = new createjs.SpriteSheet(model.ssInit);

        // add reversed frames
        // NOTE: removed because there is lag switching between spritesheets
        //createjs.SpriteSheetUtils.addFlippedFrames(this._s, true, false, false), 

        this.initialize();
    };

    AbstractCharacter.prototype = Object.create(createjs.BitmapAnimation.prototype);
    AbstractCharacter.prototype.constructor = AbstractCharacter;

    // speed constant
    AbstractCharacter.prototype.SPEED = 10;

    // from Flash CS6
    AbstractCharacter.prototype.BitmapAnimation_initialize = AbstractCharacter.prototype.initialize;

    /**
     * moves a character to a destination and sets their state at the end of the move
     * @param  {object} destination destination coordinates {x:XX}
     * @param  {string} nextAction  the next action to perform
     * @return {null}
     */
    AbstractCharacter.prototype.moveTo = function(destination, nextAction) {
        nextAction = nextAction || 'idle';

        if (destination) {
            if (destination.x < this.x) {
                this.walkLeft();
            } else {
                this.walkRight();
            }

            this.model.destination = destination;
            this.model.nextAction = nextAction;
        }
    };

    /**
     * public method to perform action
     * @param  {string} room   name of the current room the character is in
     * @param  {string} action action name
     * @param  {object} params any parameters required by the action
     * @return {null}
     */
    AbstractCharacter.prototype.act = function(room, action, actionparams) {
        //console.log(action);
        switch (action) {
            case 'walk' :
                this.moveTo(actionparams, 'idle');
                break;

            case 'talk' :
                this.moveTo(actionparams, 'talk');
                break;

            case 'sleep' :
                this.moveTo(this.model.actions.room[room].sleep, 'sleep');
                break;


        }
    };

    /**
     * onTick callback for use with easeljs
     * @return {null}
     */
    AbstractCharacter.prototype.onTick = function() {
        if (this.model.destination) {
            var destination = this.model.destination, 
                speed;

            if (destination.x < this.x) {
                speed = -this.SPEED;

                if (this.x + speed < destination.x) {
                    this.endMove(destination);
                } else {
                    this.x += speed;
                }
            } else {
                speed = this.SPEED;

                if (this.x + speed > destination.x) {
                    this.endMove(destination);
                } else {
                    this.x += speed;
                }
            }
        }
    };

    /**
     * finishes move by calling nextAction() and clearing away desination and nextAction vars
     * @param  {object} destination format {x:XX}
     * @return {null}
     */
    AbstractCharacter.prototype.endMove = function(destination) {
        //console.log('ending move');
        this.x = destination.x;
        this[this.model.nextAction]();

        this.model.destination = null;
        this.model.nextAction = null;
    };

    /**
     * these methods come from Flash CS6
     * the only difference is that I've removed
     * the reference to the Object prototype
     *
     * scaleX used instead of flipped frames
     */
    AbstractCharacter.prototype.initialize = function() {
        this.BitmapAnimation_initialize(this._s);
        this.idle();
    };

    AbstractCharacter.prototype.idle = function(){
        //console.log('idle');
        this.gotoAndPlay("idle");
        this.scaleX = 1;
    };

    AbstractCharacter.prototype.idleLeft = function(){
        //console.log('idle left');
        this.gotoAndPlay("idleside");
        this.scaleX = 1;
    };

    AbstractCharacter.prototype.idleRight = function(){
        //console.log('idle right');
        // this.gotoAndPlay("idleside_h");
        this.gotoAndPlay("idleside");
        this.scaleX = -1;
    };

    AbstractCharacter.prototype.walkLeft = function(){
        //console.log('walk left');
        this.gotoAndPlay("walk");
        this.scaleX = 1;
    };

    AbstractCharacter.prototype.walkRight = function(){
        //console.log('walk right');
        // this.gotoAndPlay("walk_h");
        this.gotoAndPlay("walk");
        this.scaleX = -1;
    };

    AbstractCharacter.prototype.talk = function(){
        //console.log('talk');
        this.gotoAndPlay("talk");
        this.scaleX = 1;
    };

    AbstractCharacter.prototype.sleep = function(){
        //console.log('sleep');
        this.gotoAndPlay("sleep");
        this.scaleX = 1;
    };

    // public interface
    return AbstractCharacter;
});