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

cmd/mesh-host/nodeagent.go

@@ -648,14 +648,9 @@ func nodeAgent(ctx context.Context, opts options, signer ed25519.PublicKey, trus
 		shadowHooks := hooks
 		shadowHooks.refused, shadowHooks.certify = nil, nil
 		shadowEnv := composerEnv(session, node, say, shadowHooks)
-		// And, after each answer, what runs of an own secret the answer says the vault holds another value of: handed to
-		// the vault only while a node applied the controller's compositions (issue 1126, cause C4; ownresync), so nothing now.
-		composes := &composesNow{}
-		resync := ownResync(session, node, say, shadowEnv, composes)
 		shadow := selfcompose.NewShadow(shadowEnv,
 			func(ctx context.Context, answers map[string]delivery.CandidateAnswer) {
 				session.NoteCandidates(ctx, delivery.WithValuesDiffer(answers))
-				go resync.take(ctx, answers)
 			})
 		go shadow.Keep(run, link.Backoff) // this run's alone: a switch begins a run, and its shadow, again
 		// Its own composer, always (issue 1126, A7): a composition made elsewhere (the controller's, in the node's
@@ -664,7 +659,6 @@ func nodeAgent(ctx context.Context, opts options, signer ed25519.PublicKey, trus
 		composer := selfComposer(session, node, hooks, say)
 		machinesNow.Store(composer) // the machines a failing network part points at, by the placements (issue 774)
 		composerNow.Store(composer) // what the verb compose asks a pass of, this run's alone
-		composes.set(delivery.ComposesOwn)
 		env.Composed, env.SelfComposed, env.Policy = composer, true, composer.Policy
 		env.HoldsData = composer.HoldsData // what runs from the kept declaration says Data as its manifest does
 		session.NoteComposes(linked, delivery.ComposesOwn, "it composes its own modules, and applies no composition made elsewhere")

cmd/mesh-host/nodekey.go

@@ -26,12 +26,10 @@ const (
 )
 
 // heardKey is the vault's own public key as its answer to node-key gave it (ADR 0547 clause 9, issue 1945): the key the
-// bus node hands the loaded list's hashes sealed to. One for the process, as the key stated is; kick is the follower of
-// the user list on the link open now, told when the key is first heard or changes.
+// bus node hands the loaded list's hashes sealed to. One for the process, as the key stated is.
 type heardKey struct {
-	mu   sync.Mutex
-	pem  string
-	kick func()
+	mu  sync.Mutex
+	pem string
 }
 
 // vaultKey is the vault's key this engine heard.
@@ -43,8 +41,7 @@ func (h *heardKey) get() string {
 	return h.pem
 }
 
-// heard keeps the key a node-key answer gave, and tells the follower when it is a first or changed one. An answer
-// with no key (a vault before this one) changes nothing.
+// heard keeps the key a node-key answer gave. An answer with no key (a vault before this one) changes nothing.
 func (h *heardKey) heard(answer json.RawMessage) {
 	var a struct {
 		VaultKey string `json:"vault_key"`
@@ -53,24 +50,8 @@ func (h *heardKey) heard(answer json.RawMessage) {
 		return
 	}
 	h.mu.Lock()
-	changed := a.VaultKey != h.pem
 	h.pem = a.VaultKey
-	kick := h.kick
 	h.mu.Unlock()
-	if changed && kick != nil {
-		kick()
-	}
-}
-
-// following names the follower told when the key changes, and tells it at once when a key is known.
-func (h *heardKey) following(kick func()) {
-	h.mu.Lock()
-	h.kick = kick
-	known := h.pem != ""
-	h.mu.Unlock()
-	if known && kick != nil {
-		kick()
-	}
 }
 
 // nodeKeyReask is how often the key is stated again though it did not change, so a changed vault key is heard: the

cmd/mesh-host/nodekey_test.go

@@ -162,29 +162,22 @@ func asksAgainUntilItHearsTheVaultsKey(t *testing.T) {
 }
 
 // The statement a host makes names this contract (issue 786), one above the vault's box. And the vault's key its
-// answer gives is kept, told to the follower once when first heard and again only when changed; an answer without one
-// (an older vault) or with no public key changes nothing (ADR 0547 clause 9).
+// answer gives is kept; an answer without one (an older vault) or with no public key changes nothing (ADR 0547 clause
+// 9).
 func TestTheNodeKeyContractIsThirteen(t *testing.T) {
 	if link.NodeKeyContract != 13 {
 		t.Errorf("NodeKeyContract %d", link.NodeKeyContract)
 	}
 	h := &heardKey{}
-	kicks := 0
-	h.following(func() { kicks++ })
 	h.heard(json.RawMessage(`{"recorded":true}`))
 	h.heard(json.RawMessage(`{"recorded":true,"vault_key":"not a key"}`))
-	if h.get() != "" || kicks != 0 {
-		t.Fatalf("an answer with no key was kept: %q, %d kicks", h.get(), kicks)
+	if h.get() != "" {
+		t.Fatalf("an answer with no key was kept: %q", h.get())
 	}
 	pem := "-----BEGIN PUBLIC KEY-----\nAAAA\n-----END PUBLIC KEY-----\n"
 	answer, _ := json.Marshal(map[string]any{"recorded": true, "vault_key": pem})
 	h.heard(answer)
-	h.heard(answer)
-	if h.get() != pem || kicks != 1 {
-		t.Fatalf("key %q, %d kicks, want the key and one", h.get(), kicks)
-	}
-	h.following(func() { kicks += 10 })
-	if kicks != 11 {
-		t.Fatalf("a follower named after the key was heard was not told: %d", kicks)
+	if h.get() != pem {
+		t.Fatalf("key %q, want the key", h.get())
 	}
 }

cmd/mesh-host/ownresync.go

@@ -1,94 +0,0 @@
-package main
-
-import (
-	"context"
-	"encoding/json"
-	"sync"
-	"time"
-
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-
-	"github.com/novox/mesh-host/internal/identity"
-	"github.com/novox/mesh-host/internal/link"
-	"github.com/novox/mesh-host/internal/ownresync"
-	"github.com/novox/mesh-host/internal/selfcompose"
-)
-
-// composesNow is whose compositions this run of the agent applies, once decided ("" before).
-type composesNow struct {
-	mu  sync.Mutex
-	now string
-}
-
-func (c *composesNow) set(s string) { c.mu.Lock(); c.now = s; c.mu.Unlock() }
-func (c *composesNow) get() string  { c.mu.Lock(); defer c.mu.Unlock(); return c.now }
-
-// resyncStep is the step that hands the vault what runs of an own secret a shadow answer says another value of (issue
-// 1126, cause C4; internal/ownresync): one pass at a time, and the last answers taken again once the agent has decided
-// whose compositions it applies.
-type resyncStep struct {
-	r    *ownresync.Resync
-	one  sync.Mutex
-	mu   sync.Mutex
-	last map[string]delivery.CandidateAnswer
-	// tries and pending are the step taken again after a bound when a read or an ask the bus did not answer stopped it
-	// (Outcome.Retry, issue 1126, 2026-10-28), one wait at a time.
-	tries   int
-	pending bool
-}
-
-func ownResync(session *link.Session, node string, say func(string), env selfcompose.Env, composes *composesNow) *resyncStep {
-	return &resyncStep{r: ownresync.New(ownresync.Env{Node: node, Composes: composes.get, Running: env.Running,
-		Get: env.Get, Unseal: env.Unseal, Seal: identity.Seal, Say: say,
-		Ask: func(ctx context.Context, verb string, args map[string]any) (json.RawMessage, error) {
-			return session.AskVault(ctx, verb, args)
-		}})}
-}
-
-// take keeps answers as the last and takes them.
-func (s *resyncStep) take(ctx context.Context, answers map[string]delivery.CandidateAnswer) {
-	s.mu.Lock()
-	s.last = answers
-	s.mu.Unlock()
-	s.again(ctx)
-}
-
-// again takes the last answers, and once more after a bound (selfcompose.LaterWait) while the bus did not answer for one.
-func (s *resyncStep) again(ctx context.Context) {
-	s.one.Lock()
-	defer s.one.Unlock()
-	s.mu.Lock()
-	last := s.last
-	s.mu.Unlock()
-	if last == nil {
-		return
-	}
-	retry := false
-	for _, o := range s.r.Take(ctx, last) {
-		retry = retry || o.Retry
-	}
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	if !retry {
-		s.tries = 0
-		return
-	}
-	if s.pending || ctx.Err() != nil {
-		return
-	}
-	wait := selfcompose.LaterWait(s.tries)
-	s.tries++
-	s.pending = true
-	go func() {
-		select {
-		case <-ctx.Done():
-		case <-time.After(wait):
-		}
-		s.mu.Lock()
-		s.pending = false
-		s.mu.Unlock()
-		if ctx.Err() == nil {
-			s.again(ctx)
-		}
-	}()
-}