E253 feat(board): cards that wait for other cards by kvaps · Pull Request #308 · aenix-io/aeman · GitHub
[go: up one dir, main page]

Skip to content

feat(board): cards that wait for other cards - #308

Merged
kvaps merged 31 commits into
mainfrom
feat/depends-on
Nov 8, 2026
Merged

kvaps merged 31 commits into
mainfrom
feat/depends-on

Conversation

@kvaps
@kvaps kvaps commented Nov 8, 2026
Copy link
Copy Markdown
Member

A card can now wait for other cards. Spec: docs/design/dependencies.md, rows N1 to N8.

  • dependsOn on a task, a goal, an initiative or an epic: a list of cards it waits for, any card but a review. A card cannot wait for itself, its ancestors or its descendants, and cycles are refused, including those closed through inheritance (422 dependencyTarget, dependencyCycle). Checks run on the whole board even for a visitor who cannot read all of it, without naming hidden cards.
  • A dependency is met when its target is done (a plan item by its roll-up; an empty epic blocks). A card with an unmet dependency is locked; a plan item's lock is inherited by every card under it. The lock is computed, never stored, and lifts by itself when the last target finishes. The manual locked stage is unchanged.
  • status.locked, blockedBy, hiddenBlockers, blocks and dependentCustomers describe it, redacted for the visitor the same way on the listing and on the watch.
  • A target inherits the customers of the cards waiting for it, transitively, and passes them down its tree; the Customer filter sees them.
  • The badge reads LOCKED with "waiting for «X»"; the day boards show the locked mark, and the card stays movable. The drawer has a Depends on section above Under it, with a picker, and a read-only Blocks list below.
  • Drawer pickers now open at the control that was pressed, flip above it when there is no room below, and stay inside the window.

Performance on a board the size of production stays at main's level with no dependencies and close to it with hundreds.

kvaps added 30 commits November 8, 2026 09:47
A card may wait for other cards. The design fixes the stored key, the
targets and cycles the server refuses, the derived lock and how it is
inherited and redacted, how the waiting work's customers follow it,
dangling ids, the REST and MCP surface and what the watch sends.

Signed-off-by: Andrei Kvapil <kvapss@gmail.com>
A card's dependsOn names the cards it waits for. The board derives its
blockers (its own unsatisfied targets and every ancestor's), the lock,
what waits for a card, the customers of the waiting work its targets
inherit, and refuses a bad target or a cycle when asked. Nothing of it
is written down.

Signed-off-by: Andrei Kvapil <kvapss@gmail.com>
The card model carries spec.dependsOn and the derived lock the server
works out (locked, blockedBy, hiddenBlockers, blocks, the customers that
arrive through a dependency). A locked card's badge reads LOCKED until
it is done, with what it waits for as the tooltip; a stage a person set
still comes first, and the Status filter keeps reading placement. The
picker's exclusions and the drawer's lists are pure helpers.

Signed-off-by: Andrei Kvapil <kvapss@gmail.com>
A card waiting for a dependency not done yet wears the locked stage's
look on the Team and Me boards, its tooltip naming what it waits for;
the Roadmap badge's status part carries the same tooltip. Nothing the
card may do changes: it can still be planned, moved and taken.

Signed-off-by: Andrei Kvapil <kvapss@gmail.com>
The card file carries dependsOn as a list of ids. The service writes
the list whole: each new id must be a card that may be waited for and
must close no cycle, checked before anything is written; a dangling id
leaves the list on that write, and the change is logged.

Signed-off-by: Andrei Kvapil <kvapss@gmail.com>
The drawer gains "Depends on" above what sits under the card: each
card it waits for with its status, a search over the roadmap to add one
(never a review card, the card itself, its ancestors, the work under it
or one already listed) and a × to take one off, shown at once and taken
back in the server's words when it refuses. Below it, read-only, the
cards that wait for this one. A dependency the listing does not carry
is fetched by id so its row has a title and a status.

The customers the waiting work brings count among a card's own and
flow down the tree like an ancestor's; the drawer draws them grey, from
the card that waits.

Signed-off-by: Andrei Kvapil <kvapss@gmail.com>
A card resource carries spec.dependsOn and the derived status: the
lock, the blockers the reader may read with the ancestor an inherited
wait comes from, a count of the ones they may not, the cards that wait
for it, and the customers it is for through that work. The PATCH body
takes the whole list, refused as dependencyTarget or dependencyCycle.

Signed-off-by: Andrei Kvapil <kvapss@gmail.com>
spec.dependsOn and the derived status fields (locked, blockedBy,
hiddenBlockers, blocks, dependentCustomers) are read onto the card
model, and a patch carries dependsOn as the whole list.

Signed-off-by: Andrei Kvapil <kvapss@gmail.com>
PATCH spec.dependsOn and MCP update_card dependsOn write a card's list
through the cache; a visitor's write keeps the dependencies they cannot
read. A target finishing or reopening re-sends every card that waits
for it and the cards under those; a list or customer change re-sends
the card's subtree and its targets. Frames count blockers, waiting
cards and inherited customers again for their subscriber.

Signed-off-by: Andrei Kvapil <kvapss@gmail.com>
The storage spec and the plugin notes name the dependsOn key and what a
writer must and need not do; the API reference lists the field, the
derived status and the refusals; the matrix rows cite their tests.

Signed-off-by: Andrei Kvapil <kvapss@gmail.com>
T waiting for a task X under epic E, E waiting for T was accepted: X
inherits E's wait, so X waits for T, which waits for X, and both stay
locked for good. Reaching any card under the waiting card is now a
cycle.

Signed-off-by: Andrei Kvapil <kvapss@gmail.com>
A dependency the drawer's listing did not carry was fetched by id, and
a failed fetch still replaced the fetched list with a new array, which
reran the effect and fetched again without end: a hidden target, a
deleted one or a network error kept the drawer requesting. Each id is
now asked for once per drawer card, and a fetch that brings nothing
back leaves the list as it was.

Signed-off-by: Andrei Kvapil <kvapss@gmail.com>
The drawer put back the list it held when a press was made whenever
the server refused it, so an older press refused after a newer one was
shown undid the newer list. A refused or late answer now touches the
list only while its press is still the latest on the card, as a
refused priority press does.

Signed-off-by: Andrei Kvapil <kvapss@gmail.com>
The checks ran on the visitor's board, where a hidden ancestor breaks a
lineage and a hidden card ends a cycle's walk, so a wait on one's own
ancestor or a cycle through hidden cards was accepted. The backend now
judges again on the whole board, and the store does so against its
cache under the write lock, so two concurrent writes cannot close a
cycle; a refusal judged on hidden cards names none.

A visitor's list is compared with the readable part as a set, so an
unchanged set writes and logs nothing, a hidden dependency keeps its
place, and the event names only ids the caller's board holds.

Signed-off-by: Andrei Kvapil <kvapss@gmail.com>
A frame carried spec.dependsOn as built over the whole board, so a
watcher saw the uid of a target their listing leaves out. A frame now
keeps only the targets its subscriber can read, as the listing does.

Signed-off-by: Andrei Kvapil <kvapss@gmail.com>
A list a direct writer left with an id twice counted that blocker
twice. The codec now reads each id once, first seen first.

Signed-off-by: Andrei Kvapil <kvapss@gmail.com>
A re-apply replaces the list wholesale and checks no target or cycle,
as it does for customers; two replicas each adding half of a cycle land
both halves.

Signed-off-by: Andrei Kvapil <kvapss@gmail.com>
A frame skipped the dependency fields when the whole board had none
for the card, then worked its customers out over the readable chain
alone. A customer that reaches the card through a chain its watcher
cannot read, and on their board through work waiting for an ancestor,
went missing from the frame while the listing had it. Any card a
dependency touches is now worked out as the listing works it out.

Signed-off-by: Andrei Kvapil <kvapss@gmail.com>
The watch re-sent what a dependency moved only for a card it had seen
before, and judged a plan item's roll-up only along the chain the
card joined. So deleting a target epic's last open task, or moving it
out, left the waiters locked on every open board; a waiting card
deleted, fetched or moved under another plan item left its targets'
blocks and inherited customers stale; and a target renamed or
re-typed kept its old name in every blockedBy. Every target's done is
now judged again on each change, an unseen card counts as having
waited for nothing, and the parent, title and type are compared too.

Signed-off-by: Andrei Kvapil <kvapss@gmail.com>
A plan item's roll-up scanned every card, and was asked again for each
card waiting on it; Visible built a whole-board index and blockers for
every visible card on every request, dependencies or not; customers were
worked out twice per card. Roll-ups now walk only the subtree and are
kept per index, a card that waits for nothing (nor any ancestor) is
answered without a lineage, Visible counts blockers only when something
waits, and a card's customers are worked out once. Benchmarks on a
production-sized board come with it.

Signed-off-by: Andrei Kvapil <kvapss@gmail.com>
Once any card waited for another, every card change built a board
index of its own for the dependency fan-out beside the one the frames
use, and stayed in that mode after the last dependency was removed.
The fan-out now takes the change's index, done is judged for targets
alone, and the tracking stops when no card waits any more.

Signed-off-by: Andrei Kvapil <kvapss@gmail.com>
Signed-off-by: Andrei Kvapil <kvapss@gmail.com>
A visitor's listing judged a target plan item done by the part of its
roll-up their board holds, while a watch frame judged it on the whole
board: an epic whose readable task was finished and whose hidden one
was not read as done in the listing and as a blocker on the frame.
Visible now records the targets that are not done on the whole board,
and the listing reads a target's done from it.

Signed-off-by: Andrei Kvapil <kvapss@gmail.com>
A watch frame re-ran the drawer's effect while a dependency fetch was
in flight, and the cleanup dropped the answer; the ids still counted as
asked, so their rows stayed bare uids. The answer is now kept while the
drawer shows the card it was asked for.

Signed-off-by: Andrei Kvapil <kvapss@gmail.com>
The restricted listing switched to the whole board's judgement only
when some readable card had a blocker on it. A target epic done only by
tasks the visitor cannot read then fell back to the visible board, where
it has no task and is not done, and the listing showed a lock the watch
frame did not. Visible now says outright that it judged the whole
board, and the listing reads that.

Signed-off-by: Andrei Kvapil <kvapss@gmail.com>
A listing asked every card for its customers and blockers, and both
walked the line again, copying cards: on a dense board the customers of
the work waiting for a card were worked out once per card below and
above it, and a holder's blockers once per card under it. Each card's
whole-board customer answer and each holder's blockers are now kept
for the index's life, the line is walked in place, and a board on which
nothing waits answers from the card's own line. A cycle a direct
writer left gives a partial answer that is not kept.

Signed-off-by: Andrei Kvapil <kvapss@gmail.com>
Their opening lines were lost, leaving each comment a sentence's tail.

Signed-off-by: Andrei Kvapil <kvapss@gmail.com>
…m now

A visitor's dependency list was merged with the hidden dependencies of
a snapshot read outside the write lock, so a hidden dependency another
request added in between was dropped. The cache now merges under the
lock it checks and edits under, with the card as it stands then.

Signed-off-by: Andrei Kvapil <kvapss@gmail.com>
The memoizing customers walk tracked only its current path inside a
cycle a direct writer left, so it tried every order of the cycle: a
clique of ten cards took seconds, under the board's lock in the watch.
It now stops at the first card met again and answers that card by the
linear walk, each card visited once.

Signed-off-by: Andrei Kvapil <kvapss@gmail.com>
Which of the card's dependencies a visitor cannot read was decided on
the board their request read; a hidden target that reached the cache
since was taken for theirs and dropped. It is judged on the cache's
board, under the lock that merges and edits, by the visitor's rights.

Signed-off-by: Andrei Kvapil <kvapss@gmail.com>
A picker's anchor is a wrapper as wide as its row, and the shared menu
lined its right edge up with the wrapper's: the Depends on search
opened at the drawer's far end, and, placed once while its list was
still empty, ran past the bottom of the screen. The menu now opens at
the pressed control, flips above when there is more room there, stays
inside the viewport and the drawer, is no taller than the room it
opened into, and is placed again as its list fills in.

Signed-off-by: Andrei Kvapil <kvapss@gmail.com>
@kvaps
kvaps merged commit 4570e7f into main Nov 8, 2026
3 of 4 checks passed
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant

0