# Moving cards

> Manual, ask or auto — a lane moves a card only as far as you let it.

A step that finishes writes down what happened — output, exit code, real cost.
What happens to the card next is the lane's setting, and you choose it per
lane.

| | |
|---|---|
| `manual` | nothing moves. The card stays where it is until you drag it. |
| `ask` | devpit asks, naming the lane it would move the card to. |
| `auto` | it moves, and the next lane's step runs. |

`manual` is the default, and a lane set to `auto` says so on the board.

## Where you set it

In the lane's step popover, under **When it passes**: **Stay here**, which is
`manual`, or **Move to `<lane>`**. Once a destination is picked, **And moves
it** offers **When you say so**, which is `ask`, and **On its own**, which is
`auto` and is marked **no prompt**. The section only appears once the lane runs
a [step](/docs/steps): a lane with nothing on it has nothing to decide about.

With `ask`, a lane that passes rings the bell — *"`<card>` is ready for
`<lane>`"*, *"`<step>` passed. Move it when you are ready."* — and the card
waits for you.

<!-- Screenshot — the step popover, with When it passes open. -->

## Back is not the same as forward

A step can answer that its card should go back. That verdict moves the card to
the lane it came from whatever the lane's setting is, with the reason written
on the card: sending work back is the one direction that is never a surprise.
Forward is the direction that needs permission.

A card you moved on purpose while its run was going stays where you put it.
That run's verdict is about the lane it ran in, so nothing moves the card on
or back from where it stands now.

And silence is never a pass. A run that ends well but says nothing about
itself — which includes a command that exited zero — has no opinion, and a card
does not advance on an opinion nobody gave.

## What automatic never does

A lane whose step is marked as having no undo is never entered automatically,
even by `auto`. The card is offered the move instead, as the same notice `ask`
would ring. The no-undo flag already keeps a deploy from being fired by a drag;
an automatic advance that walked around it would be the same failure through a
different door.

## Nothing on a timer

Nothing schedules work, nothing retries, and nothing polls. The thread that
finished one step moves the card and starts the next lane's step in the same
breath, exactly as your dropping the card there would have. A chain of `auto`
lanes is one you built lane by lane and can see.

Two other things move cards, and neither starts a step. An agent working on a
card moves it into the lanes for work in progress and for checking — see
[the card follows the work](/docs/board). And an
[orchestrator](/docs/orchestrators) can move cards on any board linked to it.
Both are refused a lane that runs a step: entering one starts work, so they ask
you to move the card there.

Two backstops sit under it. A board cannot be saved into a circle — *"that
would send a card round in a circle"*, and a lane cannot send a card to itself.
And a card that passes through too many lanes in a row stops: the card gets a
note that *"the chain stopped here"* and the bell says *"A card stopped moving
on its own"*.
