I'd be more than happy to explore the addition of Tame.js-style CPS to the CoffeeScript compiler -- but there's a lot of prior work there already:

https://github.com/jashkenas/coffee-script/issues/241

https://github.com/jashkenas/coffee-script/issues/287

https://github.com/jashkenas/coffee-script/issues/350

Edit:

Things look a little less promising after running a simple test. This input JavaScript:

    while (i--) {
      twait {
        fs.readFile("one");
        fs.readFile("two");
      }
    }

Gets compiled into this resulting "tamed" JavaScript:

    var tame = require('tamejs').runtime;
    var __tame_fn_0 = function (__tame_k) {
        var __tame_k_implicit =  {};
        var __tame_fn_1 = function (__tame_k) {
            if (i --) {
                var __tame_fn_2 = function (__tame_k) {
                    var __tame_ev = new tame.Event (__tame_k);
                    var __tame_fn_3 = function (__tame_k) {
                        fs .readFile ( "one" ) ;
                        fs .readFile ( "two" ) ;
                        tame.callChain([__tame_k]);
                    };
                    __tame_fn_3(tame.end);
                    __tame_ev.trigger();
                };
                tame.callChain([__tame_fn_2, __tame_fn_1, __tame_k]);
            } else {
                tame.callChain([__tame_k]);
            }
        };
        __tame_k_implicit.k_break = __tame_k;
        __tame_k_implicit.k_continue = function() { __tame_fn_1(__tame_k); };
        tame.callChain([__tame_fn_1, __tame_k]);
    };
    __tame_fn_0 (tame.end);

... not so nice to work with or debug. The general conclusion of that series of tickets was that the code generation required to make this CPS transformation work with all edge cases is a bit too hairy to be worth it on balance. Depending on how much sequential async you're doing, YMMV.