(2c95d38) Gate a blocker by the column it is in, not by whether it is done, and bump to 0.33.1

check_blockers refused every move while a blocked by target was still open, so a
dependent sat in backlog until its blocker landed even when the blocker was in
reviewing and its code was there to build on. The way out was -f, which also waives
the backward and skipping guard, on every move for as long as the pair existed.

The rule is now the columns: a ticket may stand level with what it waits on but never
ahead of it, so a blocker in reviewing lets the dependent be committed and reviewed
and gates only done. util::blocks_move is the one place it is decided, taking the
status moved into and the blocker's own, and mv passes the target through. A finished
blocker still holds up nothing, answered through is_open, and a target of discarded
is answered by name rather than by its place in Status::ALL, where it sits last.

The refusal now names the status moved into and only the blockers still behind it: a
dependent told to wait for work already ahead of it has nothing to act on. The board
asks the same function about the column one stage ahead, so the blocked mark means the
card cannot advance rather than that a dependency was ever recorded, which also takes
it off cards in the two terminal columns.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Ansho Rei
2026-09-10 11:38:17 +02:00
co-authored by Claude Opus 5
parent 9c224fb768
commit ead3c4340d
15 changed files with 409 additions and 90 deletions
+7 -6
View File
@@ -272,15 +272,16 @@ as above. Then confirm with `worklane show`.
### A move is refused by a blocker
```
Cannot move 'Beta' while it is blocked by:
Cannot move 'Beta' to reviewing while it is blocked by:
...
Use --force (-f) to move it anyway.
A ticket cannot move ahead of what it waits on. Use --force (-f) to move it anyway.
```
Working as intended: a ticket cannot advance while something it waits on is unfinished.
Finish the blocker, or use `-f` if the dependency is no longer real. Note that the
relation stays on the ticket and will refuse the next move too, and there is no way to
take a relation off, so `-f` is the answer every time until the blocker is done.
Working as intended: a ticket may stand level with what it waits on but not ahead of it,
so this move was one column too far. Advance the blocker to that column, which is usually
the answer and costs nothing, or use `-f` if the dependency is no longer real. If it is
not real at all, take the edge off instead of forcing every move:
`worklane relate <ticket> --clear blocked-by <blocker>`.
If the message says `is blocked by X, which is not on the board`, the blocker has been
deleted. That is a warning rather than a refusal and the move goes through.
+4 -2
View File
@@ -113,8 +113,10 @@ wrong by however much the guess was wrong.
The rules a dating plan has to keep:
- **Nothing is dated before the ticket it is blocked by.** Read the Relations first and
date blockers ahead of their dependents. A dependent dated before its blocker is a date
`mv` will refuse to honour anyway.
date blockers ahead of their dependents, or on the same day: a dependent may be worked
and reviewed alongside its blocker, so the two can share a date, but a dependent dated
earlier is a date `mv` will refuse to honour anyway, since only the blocker's own
landing lets it land.
- **A blocker left undated makes its dependent's date a fiction.** Either date both or
neither.
- **Date what fits, not what exists.** Ask how much capacity the week holds, or take the
+6 -2
View File
@@ -35,8 +35,12 @@ comments are where the intent moved after filing. A criterion that contradicts a
is one of the more useful things you can find: it means the ticket was not updated when
the plan changed, and one of the two is now lying to whoever reads the board.
Read the Relations too. A `blocked by` that is not done, or a `regression of`, changes
what the change was allowed to do and what the review has to check twice.
Read the Relations too. A `blocked by` that has not landed, or a `regression of`, changes
what the change was allowed to do and what the review has to check twice. A ticket
reaching review while its blocker is still in review is allowed by the board, so it is
normal rather than a fault, and it is exactly the case where the code under review may be
resting on work that has not landed: check that it does not assume the blocker is
finished.
## 2. Find the work
+18 -8
View File
@@ -32,8 +32,9 @@ go straight to `reviewing` and has to be walked through `committed` anyway. Doin
front is the same two commands in a more useful order. `-f` allows a backward or
skipping move, for correcting a mistake.
A move is also refused while the ticket is blocked by one that is not done yet, see
[Relating tickets](#relating-tickets).
A move is also refused while it would take the ticket a column ahead of one it is
blocked by: a pair can be committed together and reviewed together, and only the move to
`done` waits for the blocker to land. See [Relating tickets](#relating-tickets).
`mv` stamps the time as it goes: `Committed On`, `Submitted On`, `Completed On` and
`Discarded On`, shown by `show` among the rest of the metadata. They **accumulate**, so a
@@ -63,7 +64,7 @@ What it means everywhere else:
`ls discarded` and `--ids` still reach it
- A campaign counts a discarded member as **finished**: the work left the campaign rather
than sitting in it unfinished
- A discarded ticket **blocks nothing**, so a ticket waiting on it can move
- A discarded ticket **blocks nothing**, so a ticket waiting on it can move anywhere
- Discarding a ticket that open tickets are blocked by is **refused**, naming them: their
plans depended on this work, so they need a look first. `-f` says you looked
- Getting it back is a backward move, so it needs `-f`:
@@ -253,11 +254,20 @@ tickets each blocking the other is two facts and the block shows both. A symmetr
comes off with `--clear` at the end that stores it, since that is the only end holding a
line to remove.
`--blocked-by` is enforced: `mv` refuses to move a ticket while a ticket it is blocked by
is not in `done` or `discarded`, whichever move it is, and names every open blocker. `-f`
moves it anyway, beside the backward and skipping moves it already allows. It is enforced
from the other end too: discarding a ticket that open tickets are blocked by is refused,
naming them. The other two kinds are reference data and never refuse anything.
`--blocked-by` is enforced by the column: **a ticket cannot move to a status ahead of
the one its blocker is in**, and standing level with it is allowed. So a blocker in
`reviewing` lets the dependent be committed and submitted for review and refuses only
`done`; a blocker still in `backlog` holds the dependent in `backlog`. With several
blockers the least advanced one sets the ceiling, and the refusal names the status you
tried to move to and every blocker still behind it. A blocker in `done` or `discarded`
holds up nothing at all.
That is what makes it worth recording an edge on work you are about to start rather than
work you have finished: waiting on a ticket in review costs nothing until the last move.
`-f` moves past it anyway, beside the backward and skipping moves it already allows. It
is enforced from the other end too: discarding a ticket that open tickets are blocked by
is refused, naming them. The other two kinds are reference data and never refuse
anything.
Recording a relation the ticket already holds reports no change. A ticket cannot relate
to itself, and a target that later disappears shows as `_missing_` rather than silently
+1 -1
View File
@@ -523,7 +523,7 @@ export const uncheck = checkboxTool("uncheck");
*/
export const relate = tool({
description:
"Record a relation from one ticket to another, or take one off. Kinds: blocked-by means this one waits on that one and its moves are refused while the target is open; regression-of means this one broke that one's fix; relates-to is a neighbour with no dependency. The edge is stored on the ticket you name alone, and show derives the other end for the target, so never record both directions.",
"Record a relation from one ticket to another, or take one off. Kinds: blocked-by means this one waits on that one and cannot move to a status ahead of it, so it may be committed and reviewed alongside the target and only lands once the target does; regression-of means this one broke that one's fix; relates-to is a neighbour with no dependency. The edge is stored on the ticket you name alone, and show derives the other end for the target, so never record both directions.",
args: {
ticket: tool.schema
.string()