Remove what only served the controller's compositions: the own-secret resync, the shadow's wants watch and the vault key's follower

Every node composes its own since group A (issue 1126), so the resync that handed the vault an own secret's value
while a node applied the controller's compositions never runs, the shadow's answers read no want, and nothing follows
the heard vault key any more.

Claude-Session: https://claude.ai/code/session_01NcbgfJ9Gum47zkFKWRaovL

internal/selfcompose/shadow.go

@@ -32,8 +32,6 @@ type Shadow struct {
 	mu         sync.Mutex
 	candidates map[string]map[string]candidateKey // by proposal, by node
 	answers    map[string]delivery.CandidateAnswer
-	// wants are the node's wants by module (agent.NodeModule for its own); a change of one answers again.
-	wants map[string]delivery.Want
 	// ran is, by module, the digest the module's have says runs: what runs, where the agent's list holds only the copy
 	// from the declaration kept before the switch (issue 1126, probe #532 on shanks).
 	ran map[string]string
@@ -64,7 +62,7 @@ type answeredAt struct {
 }
 
 // inputWords name the shadow's inputs, in Run's order, as an answer says which of them woke it.
-var inputWords = [...]string{"the candidate", "placement", "records", "modules", "values", "haves", "wants"}
+var inputWords = [...]string{"the candidate", "placement", "records", "modules", "values", "haves"}
 
 // wokenBy says what moved between the answer a proposal stands at (had, when done) and the one about to be composed (at):
 // its first answer, a retry, its candidate's revisions, or the inputs that changed, by their words.
@@ -99,7 +97,7 @@ type candidateKey struct {
 // NewShadow is the shadow composer of one node; answer writes the node's answers into its own have key.
 func NewShadow(env Env, answer func(ctx context.Context, answers map[string]delivery.CandidateAnswer)) *Shadow {
 	return &Shadow{c: New(env), answer: answer, candidates: map[string]map[string]candidateKey{},
-		answers: map[string]delivery.CandidateAnswer{}, wants: map[string]delivery.Want{}, ran: map[string]string{}}
+		answers: map[string]delivery.CandidateAnswer{}, ran: map[string]string{}}
 }
 
 // Keep runs the shadow until ctx ends, beginning again after backoff(try) whenever it stops: an input it cannot watch
@@ -141,7 +139,6 @@ func (s *Shadow) Run(ctx context.Context) error {
 	defer cancel()
 	s.mu.Lock()
 	s.candidates = map[string]map[string]candidateKey{}
-	s.wants = map[string]delivery.Want{}
 	s.ran = map[string]string{}
 	s.answered = map[string]answeredAt{}
 	s.moved = [len(inputWords)]uint64{}
@@ -159,8 +156,6 @@ func (s *Shadow) Run(ctx context.Context) error {
 		{ResolvedBucket, node + ".>", (*Composer).takeValue, nil},
 		// What this node runs moved: an apply ends in its module's have.
 		{delivery.HaveBucket, node + ".>", nil, nil},
-		// Its wants.
-		{delivery.AssignerWantsBucket, "want." + node + ".>", nil, nil},
 	}
 	type tagged struct {
 		in int
@@ -225,8 +220,6 @@ func (s *Shadow) Run(ctx context.Context) error {
 			case t.in == 5:
 				folded := c.takeModuleHave(t.u)
 				changed = s.takeRan(t.u) || folded
-			case t.in == 6:
-				changed = s.takeWant(t.u)
 			default:
 				changed = c.takeChanged(ins[t.in], t.u)
 			}
@@ -685,33 +678,6 @@ func sameAnswer(a, b delivery.CandidateAnswer) bool {
 	return errA == nil && errB == nil && string(x) == string(y)
 }
 
-// takeWant takes one of the node's wants, and says whether it changed.
-func (s *Shadow) takeWant(u agent.Update) bool {
-	module := ""
-	var w delivery.Want
-	if _, err := delivery.ParseWantNodeKey(u.Key); err == nil {
-		module = agent.NodeModule
-	} else if node, m, err := delivery.ParseWantKey(u.Key); err == nil && node == s.c.env.Node {
-		module = m
-		if !u.Deleted {
-			if w, err = delivery.DecodeWant(u.Value); err != nil || w.Removed || w.FP == "" {
-				u.Deleted = true
-			}
-		}
-	} else {
-		return false
-	}
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	old, had := s.wants[module]
-	if u.Deleted {
-		delete(s.wants, module)
-		return had
-	}
-	s.wants[module] = w
-	return !had || old.FP != w.FP
-}
-
 // sameValue says whether two sealed values open, with this node's key, to the same value; unknown when either does not
 // open (or the node holds no opener). Only the comparison leaves: never a value (issue 1126, the shadow shows its work).
 func (c *Composer) sameValue(a, b string) (same, known bool) {