Exiting a Promise early
I realize this question is old now, but it's intriguing and still getting a number of views, so I though I would give it a shot.
Now days there's a very easy solution to this: Just use async/await syntax instead so that you can use normal flow-control statements to get the job done. However, I'll write this under the assumption that this task needs to be done in legacy es5.
Lets take a simplified example. A lot of the links in your promise chain tended to have a structure such as this:
firstTask()
    // before...
    .then(function () {
        return asyncTask()
            .catch(function (err) {
                // handle catch
                return Promise.reject('DONE'); // This gets caught at the end of the promise-chain and ignored
            });
    })
    // after...

You're right in assuming that it's not such a great idea to be rejecting with a sentinel like that in order to skip over future .then()s. The proper solution is to restructure this in order to make it so there's nothing that needs to be skipped over. The following would have the same effect, but without needing to reject with a sentinel.
firstTask()
    // before...
    .then(asyncTask)
    .then(
        function () {
            // after ...
        },
        function () { /* handle catch */ }
    )

While this does fix the issue, you'll notice an important problem: The // after ... part is now nested a couple levels deep. Each time we need this skip-to-the-end behavior, we will have to add even further nesting, and that's just gross ️ - we just got ourselves right back into the callback hell that promises were designed to prevent. This is an unfortunate limitation to promises, however, even callback hell can be tamed with some good coding practices. If we split up the logic into multiple functions, then we can avoid having too much nesting happening in one place.
firstTask()
    // before...
    .then(asyncTask)
    .then(
        doAfter,
        function () { /* handle catch */ }
    )

function doAfter() {
    // after ...
}

And now we have a recipe to fix up this code! Below I have an (untested) version of the original code that's been fixed up so it doesn't need to break out of a promise chain anymore. I did make one change that simplified things a bit: I took out the places where you would catch an error, then re-reject it like this Promise.reject({ text: 'file rename failed', err: err }), which you later re-caught, logged the error, and returned the text to the user. The end-user doesn't need to know what specific internal detail went wrong, simply giving back &quot;Internal Server Error&quot; should be good enough.
var id = req.param.id;

promisifiedWriteFile('src.txt', 'foobar')
    .then(function () { return exec('my-command src.txt') })
    .then(onExecute, onExecuteError)
    .then(function (response) { res.send(response) })
    .catch(function (err) {
        res.status(500).send('Internal server error');
        console.error(err.message);
        console.error(err.stack);
    });

function onExecute (ret) {
    var fileHasBadName;
    return isFileNameBad()
        .then(function (fileHasBadName_) {
            fileHasBadName = fileHasBadName_;
            if (fileHasBadName) return fixBadFileName(id);
        })
        .then(function () {
            return fileHasBadName ? 1 : countPagesInOutput(id);
        })
        .then(function (pages) {
            return { output: ret.stderr, id: id, pages: pages };
        });
}

function onExecuteError (err) {
    return { error: err.stderr, id: id, pages: 0 };
}

function isFileNameBad() {
  return promisifiedStat('resultWithBadName.txt')
    .then(function () { return true }, function () { return false })
}

function fixBadFileName(id) {
    return promisifiedRename('resultWithBadName.txt', 'result' + id + '.txt')
}