The queues

The queues, and who accepts them

Where does work come from, and who may start it? Work is a queue, and nothing starts by itself: the operator accepts it, and says how many steps it may take.

What a queue is

The queue is the unit of work. It is not a list of messages and not a git branch: it is the container that carries one request from the moment it is accepted to the moment it closes. It has exactly these parts.

• An originator — a request from the operator, or a task the hub opened itself. The queue says which.
• A kind — work, or conversation. The kind is what tells the engine that a queue with nothing left to do waits instead of closing.
• A chain of steps — the ordered tasks the queue carries; the order is the order the worker chose when it packed them.
• One session — the agent's conversation, carried from step to step. The third step knows what the first one said, without being told again.
• A step ceiling — declared when the queue is accepted, with what is left of it.
• A state — open, paused or closed.

Nothing starts by itself

Acceptance is the operator's act. A request waits until he turns it into a queue, and the ceiling is declared with the acceptance — not guessed later. Raising it is +N, and +N is a new acceptance, never a silent extension: the number a queue may spend is a number somebody said out loud.

The count survives a pause. A queue that sleeps does not start over, and a restart of the engine does not undo the choice that put it in.

Who goes first

The dispatcher carries queues in arrival order, because that is the rule chosen when the queue took the tree's place: whoever arrived first does not wait for ever behind whoever arrived later.

Urgency orders tasks inside a lane, not queues. It is one scale, 0..100, and the operator's own requests are born at 90 — just under the top, because a human request must never lose against the traffic the system generates for itself. Above 100 is the hyper-priority band, and only a task there may preempt a place already taken.

A queue that holds a slot keeps it until it closes; the arrival waits.

At the ceiling it comes back

When the chain reaches the step ceiling, the queue closes and returns to the operator saying what it did, what is missing and why. That is a return, not a bounce: nothing walks the task toward an escalation nobody asked for, and the shape of the answer is the same as any other delivery.

The order is not the documentation

A chain says the order; the documents say why. Every queue is asked for three — plan, roadmap, progress — and the review refuses a queue whose documents are missing. That is the whole reason the trace is the product and not a side effect: a step that lies can be contested, and the record stays where it was.

What the engine does not do

The engine does not build and does not merge; it runs no tests and judges no prose. The review is deterministic and executes nothing: it checks that every artifact a delivery declares exists where it says, and that the queue's documents are there. The merge is the worker's act, in the project's own repository, under the project's own rules.