One body citing what genuinely waits on it makes a set, and the walk argues that cannot happen

[iderex]

reciprocal in internal/blockers/blockers.go reports a set of issues in which
every member waits on another member of the same set. Its edges are every issue
number a body names, and it states a bound on that reading together with an
argument for why the bound is survivable:

sed -n '265,270p' internal/blockers/blockers.go
// The edges are the references the two questions above already resolve, so
// this reading inherits their bound: a body naming a number in passing is read
// as a wait. What makes the inherited over-reading survivable here is that a
// set needs the reference to run in both directions, so both bodies have to be
// describing something other than a wait, in opposite directions, at once. A
// one-sided mention produces no set.

Run 2026-09-07 at ee44ae2.

The argument holds where neither of the two issues genuinely waits. It does not
hold where the issue being cited genuinely waits on the one citing it: then the
return edge is a real wait, only the outgoing one is a mention, and a single body
citing in passing closes the loop by itself. A one-sided mention does produce a
set, and this board is reporting one today.

The set today

go run . blockers | tail -2
  WAITING ON ITSELF: #35, #36, #50, #63, #90 each wait on another issue in this set, so nothing closing outside it makes any of them available
16 issue(s) read, 0 naming no issue, 0 no longer blocked, 0 unresolved, 1 set(s) waiting on themselves.

for n in 35 36 50 90; do
  printf '#%-3s -> ' "$n"
  gh api repos/Flowfin/site/issues/$n --jq '.body' \
    | grep -oE '(^|[^0-9A-Za-z_&/#-])#[0-9]+' | grep -oE '#[0-9]+' | sort -u | tr '\n' ' '
  echo
done
#35  -> #34 #63
#36  -> #35 #63
#50  -> #37 #48 #63
#90  -> #22 #38 #39 #63

Both run 2026-09-07 at ee44ae2. Every edge in that set other than the browser-pin
issue's own outgoing ones runs into it, and its body names all four back. Three of
those four are citations rather than waits, and its first paragraph says so in its
own words before naming them: the timing budget and the origin assertion are named
in the paragraph listing which legs consume the browser, and the departure record
is named as what carries the reasons. Only the accessibility gate is a wait, and
that one is a joint landing decided on 2026-08-24.

So three of the five members stand on one body's citations while every return edge
is genuine, which is exactly the shape the comment above says cannot occur.

The second cost, which falls on how bodies are written here

Every number in a body is an edge, inside a code fence as readily as in prose:

grep -n '^var reference' internal/blockers/blockers.go
112:var reference = regexp.MustCompile(`(^|[^0-9A-Za-z_&/#-])#([0-9]+)`)

Run 2026-09-07. Bodies on this board carry pasted command output as evidence, and
an issue quoting the evidence for what it waits on manufactures the waits while it
documents them. Narrowing the browser-pin issue's stale five to the one leg its own
decision names had to leave the quotation in a comment for that reason, and said so
in the body where a later reader meets it.

What it costs to leave as it is

The run reports a set that is mostly artefact, and nothing in the output separates
a member that is genuinely stuck from one that is only cited. The whole value of
that line is that somebody reads it and looks; a line that is three-fifths artefact
is the one people stop reading. It also pushes the repair the wrong way, because
the cheapest way to leave the set is to delete numbers a reader wants out of prose.

Done when

A declared dependency is separable from a mention by a form a body carries rather
than by a pattern over prose; a body may quote evidence containing issue numbers
without those numbers becoming edges; the run says which reading it used; and the
set this board reports is re-read against that rule, with what remains of it being
issues that genuinely wait on each other.

Which form declares a dependency is a rule for this board and is not decided here.