Planner, builder, reviewer: wiring the handoffs

You split the work into roles: a planner session, a builder and a reviewer, like the developer whose loop ran planner, then builder, then reviewer, then a fresh second reviewer. It works until two sessions grab the same task, or the reviewer never hears the builder finished, and you're back to copying text between terminals.

Each session is separate and starts blank. They can't see each other. Unless something shared sits between them, you carry the plan to the builder, the result to the reviewer, and the verdict back.

Two sessions reading the same task list at the same moment will both think the top task is free.

Copy-paste between terminals. You're the bottleneck, and you're asleep.

One session playing all three roles. The reviewer then shares the builder's context and its blind spots.

One shared markdown file that everyone edits. Two writers at once, and one overwrites the other.

Most of this isn't us.

Keep one list of tasks, each with a single owner.

Make taking a task a separate, all-or-nothing step, so a second session trying the same task is refused instead of duplicating it.

Start the reviewer fresh, without the builder's notes, reading only the change.

Have each role write its result where the next role looks first.

In our system, taking a task is a single step that either succeeds or is refused. Two sessions can't both win it.

In July a worker went to take a task and was refused, because another session had claimed it about six seconds earlier. It stopped and wrote down why instead of doing the same work twice. The step exists because of how the project began: in April one session was about to pick up work another was already doing, neither knew, and the operator had to notice and pass the message between them.

Vinculum keeps the task list, makes taking a task all-or-nothing, and records each role's result where the next role reads it.

Sessions still don't negotiate with each other. Real conflicts still come to you.