replace eager links by trees

5 files changed, 13 insertions, 32 deletions

diff --git a/docs/dashboard.md b/docs/dashboard.md
index 70397a0..1fe51dc 100644
--- a/docs/dashboard.md
+++ b/docs/dashboard.md
@@ -99,9 +99,6 @@ else the fresher. Then:
 * **Dotted**: one end reports no links: what is drawn may be out of date.
 * **Narrow, over a red band**: either end holds the other dormant, or the path in use
   is down (no path to the peer answers; `/peers` shows its connection as `null`).
-* **A chevron on the line in use**: the link is eager that way ([`peers.md`](peers.md)):
-  the end it points away from sends the other its changes as soon as it applies them,
-  rather than announcing them; one each way if both. Shown if either end says so.
 
 Messages this node exchanges run along its links as dots, from sender to receiver, all
 at one speed: over a longer link they arrive later.
@@ -330,7 +327,7 @@ another version of it (the state's `page`).
 member (`swarm::topology`), as this node computes them. The measured one is every
 member's links as it reports them in reply to a LINKS (sent to every member, at most
 512, while the producer runs). The LINKS subscribes: the member replies again whenever
-its links change (a peer, a transport, relayed, dormant, eager, or a round trip moved by a
+its links change (a peer, a transport, relayed, dormant, or a round trip moved by a
 fifth; it looks every 2 s), for 90 s, renewed every 30 s (each renewal answered), and
 ended when the producer stops; a node that is gone stops it by not renewing. A reply
 older than 90 s is left out. A member keeps 64 subscribers at most. With `links: every
@@ -367,8 +364,7 @@ every way has failed, all are tried again. Every hop does the same for what it a
 The links a member reports: its neighbours and the peers it holds dormant (a neighbour
 that goes dormant is one no more, but stays listed until it is heard from again), by
 which transport, whether only through a relay, the round trip (as the paths layer
-measures it), whether it holds the peer dormant or the path is down, which way the link
-is eager, the peer's other
+measures it), whether it holds the peer dormant or the path is down, the peer's other
 transports with a path up (each with its fastest path's round trip, and whether it goes
 only through a relay), and the peer's clock against the member's ([`measurements.md`](measurements.md),
 Per peer, `clock`). A member answers a LINKS from members only, at most every 5 s, and
diff --git a/docs/glossary.md b/docs/glossary.md
index 050a885..42c7aac 100644
--- a/docs/glossary.md
+++ b/docs/glossary.md
@@ -103,11 +103,10 @@ closest by round-trip time first.
 **relay**: in a partial mesh, a node announces new heads to its neighbours, which pull
 the changes they lack.
 
-**eager link** and **lazy link**: over a lazy link, changes are announced and pulled
-(the relay); over an eager one, a neighbour gets them as sync messages as soon as the
-other end applies them. A pull that brought changes makes a link eager in that
-direction, changes that came first another way make it lazy again (Plumtree's GRAFT and
-PRUNE).
+**writer's tree**: how a writer's changes pass on, the same on every node: from the
+member list's graph and whom each member says it reaches, each member's parent is the
+neighbour it reaches closest to the writer. Whoever applies a writer's change sends it
+at once to its children in the writer's tree; announcements catch what the tree misses.
 
 **blob**: bytes too large for one message, fetched in chunks from several peers at once:
 an epoch's snapshot change (for a rejoining node) or a remake's content (for voters).
diff --git a/docs/measurements.md b/docs/measurements.md
index f93a79a..086cd17 100644
--- a/docs/measurements.md
+++ b/docs/measurements.md
@@ -83,9 +83,7 @@ or caught up over many small messages.
 | `relay.announceRounds` | `announce_rounds_total` | Announcement rounds: our new heads to the neighbours after applying their changes (partial mesh only). |
 | `relay.pulls` | `pulls_total` | Pulls of changes we lacked from a neighbour that announced them. |
 | `relay.pullsQueued` | `pulls_queued_total` | Announcements of heads we lacked that waited for the pull in progress. Many compared with `pulls`: changes arrive from several sides at once. |
-| `relay.grafts` | `grafts_total` | Links made eager: a pull brought changes over them, which from then on the neighbour sends as it applies them ([`peers.md`](peers.md)). |
-| `relay.prunes` | `prunes_total` | Links made lazy again: changes came over them that another path had brought first. Grafts and prunes growing together, long after start: links keep switching, as when writers in different places take turns. |
-| `relay.eagerForwards` | `eager_forwards_total` | Changes forwarded over eager links: a sync message per neighbour, instead of an announcement and a pull. |
+| `relay.treeForwards` | `tree_forwards_total` | Changes passed on along writers' trees ([`peers.md`](peers.md)): a sync message per child, at once, instead of an announcement and a pull. |
 | `relay.blobRequestsDropped` | `blob_requests_dropped_total` | Blob requests not answered because too many were being answered; the requester asks again or asks another peer. Also logged as a warning, at most once a minute with the count. |
 
 ## Topology
diff --git a/docs/openapi.yaml b/docs/openapi.yaml
index 20d2ccc..b73827c 100644
--- a/docs/openapi.yaml
+++ b/docs/openapi.yaml
@@ -753,9 +753,8 @@ paths:
         those of the member list, and any a link reported goes to: `alias`, `self`,
         `dashboard`: its `--dashboard-url`), `intended` (by node ID: the neighbours the member list gives
         it, as this node computes them), `measured` (by node ID: `secsAgo` and
-        `links`, each with `peer`, `transport`, `relayed`, `down`, `rttMs`, `dormant`,
-        `eagerTo` and `eagerFrom` (the member sends the peer its changes as it applies
-        them, and the peer the member: eager links) and `others` (the peer's other transports: `transport`, `rttMs`, `relayed`), as the member
+        `links`, each with `peer`, `transport`, `relayed`, `down`, `rttMs`, `dormant` and
+        `others` (the peer's other transports: `transport`, `rttMs`, `relayed`), as the member
         answered a LINKS; ours always, the others' while fresh) and `live` (whether the
         members' links are subscribed to, `/admin/dashboard/links`). One producer
         per node makes it every 2 s while anyone looks (and for a minute after this
@@ -1977,7 +1976,7 @@ components:
               type: integer
         relay:
           type: object
-          required: [announceRounds, pulls, pullsQueued, grafts, prunes, eagerForwards, blobRequestsDropped]
+          required: [announceRounds, pulls, pullsQueued, treeForwards, blobRequestsDropped]
           properties:
             announceRounds:
               type: integer
@@ -1985,11 +1984,7 @@ components:
               type: integer
             pullsQueued:
               type: integer
-            grafts:
-              type: integer
-            prunes:
-              type: integer
-            eagerForwards:
+            treeForwards:
               type: integer
             blobRequestsDropped:
               type: integer
diff --git a/docs/peers.md b/docs/peers.md
index 9118fde..760412f 100644
--- a/docs/peers.md
+++ b/docs/peers.md
@@ -290,15 +290,8 @@ for what's missing). It pulls from one neighbour at a time (15 s timeout); neigh
 that announce heads it lacks meanwhile wait their turn and are pulled from as soon as
 the current pull is answered, if they still have something it lacks. The regular
 STATUS (every third keepalive) triggers the same pull, so gaps close within a few
-keepalive intervals. Links start lazy like this, announced over and pulled from; a
-pull that brought changes this node lacked makes the link eager in that direction
-(Plumtree's GRAFT): its STATUSes ask the neighbour for its changes as soon as the
-neighbour applies them, and the neighbour sends them at once as sync messages, without
-announcing or waiting. Changes this node had already, over an eager link, make it lazy
-again (Plumtree's PRUNE): another path brings them first. Eager links so form where
-changes actually flow, over links that deliver; announcements over the others catch
-what they miss. Every STATUS restates the link's mode, and a link starts lazy again
-whenever its sync does (a new neighbour, dormancy, a new run of the peer). A node
+keepalive intervals. Changes that pass on along a writer's tree (below) go at once,
+without announcement or pull; the announcements catch what the trees miss. A node
 that just caught up announces its heads once. In a full mesh too: the member list makes
 every member the writer's neighbour, but the writer may reach fewer of them (one behind
 NAT may reach a single one, one on libp2p alone none on Tor alone), and no node can tell