Why does this Task return early? Have I done something wrong?

I'm trying to set up a bunch of workers with some minimal coupling, but I'd like to use C# async and tasks. Not all of the tasks will be purely asynchronous (some will be completely synchronous). The motivation for doing this is that I want to create some simple methods that execute business logic, and chain them together using the System.Threading.Tasks.Task API to preserve some notion of ordering. Basically, I want to create a first task, register some continuations, and then wait for the final task to complete.

Here's the simple prototype I built just to see if what I want to do even works:

void Main()
{
    var worker = new Worker();

    var work = worker.StartWork(1, 2000);
    work.ConfigureAwait(false);

    var final = work.ContinueWith(_ => worker.StartWork(2, 0))
        .ContinueWith(ant => worker.StartWork(3, 1500));

    var awaiter = final.ContinueWith(_ => Tuple.Create(_.Id, _.Status));
    Console.WriteLine("\"final\" completed with result {0}", awaiter.Result);
    Console.WriteLine("Done.");
}

// Define other methods and classes here
class Worker {
    internal async Task StartWork(int phase, int delay) {
        Console.WriteLine("Entering phase {0} (in Task {1}) with {2} milliseconds timeout.", phase, Task.CurrentId, delay);
        if (delay > 0)
        {
            Console.WriteLine("Do wait for {0} milliseconds.", delay);
            await Task.Delay(delay);
        }

        Console.WriteLine("ending phase {0}", phase);
    }
}

The problem seems to be in awaiting waiting on the so-called awaiter task:

Entering phase 1 (in Task ) with 2000 milliseconds timeout.
Do wait for 2000 milliseconds.
ending phase 1
Entering phase 2 (in Task 769) with 0 milliseconds timeout.
ending phase 2
Entering phase 3 (in Task 770) with 1500 milliseconds timeout.
Do wait for 1500 milliseconds.
"final" completed with result (770, RanToCompletion)
Done.
ending phase 3

Is this just not supported? I thought I understood the Task API pretty well, but clearly I don't. I think that I can convert this to not use async or task, and just execute the method completely synchronously, but that seems like a bad method of doing things. The continuations that I want to run are not exactly this (they just accept a CancellationToken). There's no particular dependency on messages between tasks - I just need to preserve some notion of ordering.

Thank you.

Edit: I incorrectly used the word awaiting above: I know that accessing Task.Result is completely synchronous. My apologies.

Edit 2: What I expected to occur was that calling ContinueWith(_ => worker.Start(2, 0)) would return a task to ContinueWith, and the TPL would internally await the task returned by worker.StartWork when my user delegate returned a task. Looking at the overload list for ContinueWith, this was clearly incorrect. Part of what I'm trying to solve is how to wait from the Main method that schedules the work; I don't want to exit before all continuations have completed.

The motivation I had for using ContinueWith was that I have requirements similar to the following:

1. There are three phases to the main method.
2. Phase 1 creates three workers: a, b, and c.
3. Phase 2 starts an additional worker d upon the completion of tasks b and c, and another worker e upon completion of a and b (the dependency is that these tasks must be created in this order)
4. A process similar to this follows until all the work is complete.

If I understand the feedback in the comments correctly, I have essentially two ways I can do this:

1. Make the methods synchronous, and register the continuations myself.
2. Leave the methods marked as async Task, and use the await keyword along with the Task.WhenAll API to schedule the continuations.