Read this node's placement from its node and module keys, or its placement.<node> before the holder converts it, so a write of the holder's is composed only once its node key lands (issue 774, research 072 row 37)

cmd/mesh-host/nodeagent.go

@@ -1015,7 +1015,7 @@ type composerHooks struct {
 }
 
 func selfComposer(ctx context.Context, session *link.Session, node string, say func(string), hooks composerHooks) (*selfcompose.Composer, string) {
-	key, err := delivery.PlacementKey(node)
+	key, err := delivery.PlacementNodeKey(node)
 	if err != nil {
 		say("this node applies the controller's compositions: " + err.Error())
 		return nil, err.Error()
@@ -1079,31 +1079,55 @@ func composerEnv(session *link.Session, node string, say func(string), hooks com
 		VaultAuthority: hooks.vaultAuthority, Certify: hooks.certify}
 }
 
+// placementKeysOf is a node's node key and the pattern of the keys that say it is placed: its node key and its legacy
+// key `placement.<node>`, read while the holder may not have converted it (research 072 row 37). Its module keys say
+// nothing of whether it is placed.
+func placementKeysOf(node string) (key, keys string, err error) {
+	key, err = delivery.PlacementNodeKey(node)
+	if err != nil {
+		return "", "", err
+	}
+	legacy, _ := delivery.LegacyPlacementKey(node)
+	return key, link.WatchPatterns(key, legacy), nil
+}
+
+// anyHeld says some key holds a value.
+func anyHeld(held map[string]bool) bool {
+	for _, h := range held {
+		if h {
+			return true
+		}
+	}
+	return false
+}
+
 // endWhenUnplaced calls stop once this node's placement key is deleted from the seat's placement (after the watch
 // caught up, or gone already), so the agent begins again and applies the controller's compositions, as a node the
 // catalogue does not place does from its start: the way back (issue 1126, the seed's revert). A watch that cannot be
 // made is said; the node then returns at its next start.
 func endWhenUnplaced(ctx context.Context, session *link.Session, node string, stop func(), say link.Announce) {
-	key, err := delivery.PlacementKey(node)
+	key, keys, err := placementKeysOf(node)
 	if err != nil {
 		return
 	}
-	updates, err := bucketWatch{session, delivery.PlacementBucket}.Watch(ctx, key)
+	updates, err := bucketWatch{session, delivery.PlacementBucket}.Watch(ctx, keys)
 	if err != nil {
 		say("whether this node's key in the seat's placement state still exists is not followed (" + err.Error() + "): it returns to the controller's compositions at its next start")
 		return
 	}
-	placed := false
+	// Its node key or, before the holder converted it, its legacy key: placed while either holds a value (research
+	// 072 row 37); the holder deletes the legacy key before the node key, so the node key's delete is the last.
+	held, caught := map[string]bool{}, false
 	for u := range updates {
-		switch {
-		case u.Caught && placed:
-			continue
-		case u.Caught || u.Deleted || len(u.Value) == 0:
+		if u.Caught {
+			caught = true
+		} else {
+			held[u.Key] = !u.Deleted && len(u.Value) > 0
+		}
+		if caught && !anyHeld(held) {
 			say("this node's key in the seat's placement state is gone (" + key + "): the node agent begins again, applying the controller's compositions")
 			stop()
 			return
-		default:
-			placed = true
 		}
 	}
 	if ctx.Err() == nil {
@@ -1115,7 +1139,7 @@ func endWhenUnplaced(ctx context.Context, session *link.Session, node string, st
 // caught up, or one already there), so the agent begins again and composes its own. A watch that cannot be made is said;
 // the node then switches at its next start.
 func endWhenPlaced(ctx context.Context, session *link.Session, node string, stop func(), say link.Announce, note func(string)) {
-	key, err := delivery.PlacementKey(node)
+	key, keys, err := placementKeysOf(node)
 	if err != nil {
 		return
 	}
@@ -1124,7 +1148,7 @@ func endWhenPlaced(ctx context.Context, session *link.Session, node string, stop
 	// (no timer), says so once in the journal and in the node's own have, where the watchman reads it, and stays on the
 	// controller's compositions until its key is written. A watch the account may not make is said the same way, and the
 	// node stays until its next start.
-	updates, err := bucketWatch{session, delivery.PlacementBucket}.WatchAwait(ctx, key, func(err error) {
+	updates, err := bucketWatch{session, delivery.PlacementBucket}.WatchAwait(ctx, keys, func(err error) {
 		why := "this node's key in the seat's placement state is waited for, the state is not on the bus yet (" + err.Error() + "): it stays on the controller's compositions and is watched when the bus says the state was created"
 		say(why)
 		note(why)
@@ -1137,7 +1161,7 @@ func endWhenPlaced(ctx context.Context, session *link.Session, node string, stop
 	}
 	for u := range updates {
 		if !u.Caught && !u.Deleted && len(u.Value) > 0 {
-			say("this node's key in the seat's placement state is written now (" + key + "): the node agent begins again, composing its own modules")
+			say("this node's key in the seat's placement state is written now (" + u.Key + "): the node agent begins again, composing its own modules")
 			stop()
 			return
 		}