• ONE

One Task. Every Actor. No Bridge.

A build cycle and a board task used to live in two different queues, reconciled by a script nobody ran. Now they're one substrate task — created, ranked, claimed, and closed through the same four verbs, whether a human, a workflow, an agent, or /do itself does the work.

tasks do platform product

Every task on your board lives in the substrate. Every /do build cycle used to live in a text file only the repo could read. A script existed to reconcile the two. Nobody ever ran it.

So a task you created never reached the build queue, and a build cycle closing never moved anything the board could see. Two queues, one job, no conversation between them.

That’s closed now. Every task is the same task, wherever it started. Create it from the board, a paused workflow, or a /do plan arming itself — it ranks, gets claimed, and closes through the same four verbs. No bridge. No second queue pretending to agree with the first.

No sync, just a shared tag

There’s no reconciler behind this, and there’s no second store to keep in sync. A task carries a tag that says what it is — slug: if it’s a build plan, run: and step: if it’s a paused workflow, @actor for whoever’s holding it. That tag is the whole join.

   a task is created
   (board · workflow park · /do plan arming)
              │
              ▼
      one substrate task,
      tagged with what it is
              │
              ▼
   ranked the same way for everyone
      (learned weight, not a
       hand-set priority number)
              │
              ▼
        claimed — the lease
              │
              ▼
   closed — the mark moves the weight
              │
              ▼
        next pick is smarter

It proved itself while we were building it

We shipped this with two build loops running at once — one finishing the shared-atom wiring, the other finishing a related fix to the exact same two files. The newer loop was told to check first: has the other one already landed this. It had. So instead of re-deriving the logic, it copied the proven code across and moved on to its own next cycle.

That’s not luck. That’s the point of the tag: a plan can name another plan’s file as a dependency and act on what it finds there, the same way a person would check a coworker’s branch before starting the same fix twice.

One honest edge, on purpose

Two branches finishing related work on the same files still met at a merge conflict, and a human resolved it. We’re not waiting to automate that away. A build loop that reaches an agreement with itself and skips the person checking the merge is the failure mode here, not a missing feature. Trust gets earned cycle by cycle. Landing to the main branch stays a person’s call.

The same run also caught a real bug before it shipped: tasks:claim was silently re-tagging over an existing claimant instead of refusing — which would have broken the one guarantee this whole design leans on, that a claimed task stays claimed. The round-trip test built to prove the loop works is what found it.

What’s actually true today

  • tasks:create, tasks:claim, and tasks:link fire from the same four receivers whether a human clicks a button or /do arms a plan.
  • The build ranker reads the live substrate queue. The local weight file is a cache now, not a second truth.
  • Any Claude Code, anywhere, claims and closes a task over MCP — the same lease, the same close, a build cycle already used internally.
  • A paused workflow step is a task. Closing it resumes the run.
  • The reconciler script that used to sit between the two queues is deleted. There’s nothing left for it to reconcile.

The build queue and the task board were never actually two things pretending to be one. Now the code agrees.